25649 lines
1.1 MiB
Python
25649 lines
1.1 MiB
Python
|
# @generated from torch/_C/_VariableFunctions.pyi.in
|
|||
|
|
# mypy: disable-error-code="type-arg"
|
|||
|
|
|
|||
|
|
import builtins
|
|||
|
|
from typing import (
|
|||
|
|
Any,
|
|||
|
|
Callable,
|
|||
|
|
ContextManager,
|
|||
|
|
Iterator,
|
|||
|
|
List,
|
|||
|
|
Literal,
|
|||
|
|
NamedTuple,
|
|||
|
|
Optional,
|
|||
|
|
overload,
|
|||
|
|
Sequence,
|
|||
|
|
Tuple,
|
|||
|
|
TypeVar,
|
|||
|
|
Union,
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
import torch
|
|||
|
|
from torch import contiguous_format, Generator, inf, memory_format, strided, SymInt, Tensor
|
|||
|
|
from torch.types import (
|
|||
|
|
_bool,
|
|||
|
|
_complex,
|
|||
|
|
_device,
|
|||
|
|
_dtype,
|
|||
|
|
_float,
|
|||
|
|
_int,
|
|||
|
|
_layout,
|
|||
|
|
_qscheme,
|
|||
|
|
_size,
|
|||
|
|
Device,
|
|||
|
|
Number,
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
from torch._prims_common import DeviceLikeType
|
|||
|
|
|
|||
|
|
@overload
|
|||
|
|
def __and__(input: Tensor, other: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def __and__(input: Tensor, other: Union[Number, _complex]) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def __lshift__(input: Tensor, other: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def __lshift__(input: Tensor, other: Union[Number, _complex]) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def __or__(input: Tensor, other: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def __or__(input: Tensor, other: Union[Number, _complex]) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def __rshift__(input: Tensor, other: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def __rshift__(input: Tensor, other: Union[Number, _complex]) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def __xor__(input: Tensor, other: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def __xor__(input: Tensor, other: Union[Number, _complex]) -> Tensor: ...
|
|||
|
|
def _adaptive_avg_pool2d(input: Tensor, output_size: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]]) -> Tensor: ...
|
|||
|
|
def _adaptive_avg_pool3d(input: Tensor, output_size: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]]) -> Tensor: ...
|
|||
|
|
def _add_batch_dim(input: Tensor, batch_dim: _int, level: _int) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def _add_relu(input: Tensor, other: Tensor, *, alpha: Union[Number, _complex] = 1, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def _add_relu(input: Tensor, other: Union[Number, _complex], alpha: Union[Number, _complex] = 1) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def _add_relu_(input: Tensor, other: Tensor, *, alpha: Union[Number, _complex] = 1) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def _add_relu_(input: Tensor, other: Union[Number, _complex], alpha: Union[Number, _complex] = 1) -> Tensor: ...
|
|||
|
|
def _addmm_activation(input: Tensor, mat1: Tensor, mat2: Tensor, *, beta: Union[Number, _complex] = 1, alpha: Union[Number, _complex] = 1, use_gelu: _bool = False, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def _aminmax(input: Tensor) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
@overload
|
|||
|
|
def _aminmax(input: Tensor, dim: _int, keepdim: _bool = False) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def _amp_foreach_non_finite_check_and_unscale_(self: Union[Tuple[Tensor, ...], List[Tensor]], found_inf: Tensor, inv_scale: Tensor) -> None: ...
|
|||
|
|
def _amp_update_scale_(input: Tensor, growth_tracker: Tensor, found_inf: Tensor, scale_growth_factor: _float, scale_backoff_factor: _float, growth_interval: _int) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def _assert_async(input: Tensor) -> None:
|
|||
|
|
r"""
|
|||
|
|
_assert_async(tensor) -> void
|
|||
|
|
|
|||
|
|
Asynchronously assert that the contents of tensor are nonzero. For CPU tensors,
|
|||
|
|
this is equivalent to ``assert tensor`` or ``assert tensor.is_nonzero()``; for
|
|||
|
|
CUDA tensors, we DO NOT synchronize and you may only find out the assertion
|
|||
|
|
failed at a later CUDA kernel launch. Asynchronous assertion can be helpful for
|
|||
|
|
testing invariants in CUDA tensors without giving up performance. This function
|
|||
|
|
is NOT intended to be used for regular error checking, as it will trash your CUDA
|
|||
|
|
context if the assert fails (forcing you to restart your PyTorch process.)
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
tensor (Tensor): a one element tensor to test to see if it is nonzero. Zero
|
|||
|
|
elements (including False for boolean tensors) cause an assertion failure
|
|||
|
|
to be raised.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def _assert_async(input: Tensor, assert_msg: str) -> None:
|
|||
|
|
r"""
|
|||
|
|
_assert_async(tensor) -> void
|
|||
|
|
|
|||
|
|
Asynchronously assert that the contents of tensor are nonzero. For CPU tensors,
|
|||
|
|
this is equivalent to ``assert tensor`` or ``assert tensor.is_nonzero()``; for
|
|||
|
|
CUDA tensors, we DO NOT synchronize and you may only find out the assertion
|
|||
|
|
failed at a later CUDA kernel launch. Asynchronous assertion can be helpful for
|
|||
|
|
testing invariants in CUDA tensors without giving up performance. This function
|
|||
|
|
is NOT intended to be used for regular error checking, as it will trash your CUDA
|
|||
|
|
context if the assert fails (forcing you to restart your PyTorch process.)
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
tensor (Tensor): a one element tensor to test to see if it is nonzero. Zero
|
|||
|
|
elements (including False for boolean tensors) cause an assertion failure
|
|||
|
|
to be raised.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _assert_scalar(self: Union[Number, _complex], assert_msg: str) -> None: ...
|
|||
|
|
def _assert_tensor_metadata(a: Tensor, size: Optional[Sequence[Union[_int, SymInt]]] = None, stride: Optional[Sequence[Union[_int, SymInt]]] = None, dtype: Optional[_dtype] = None) -> None: ...
|
|||
|
|
def _batch_norm_impl_index(input: Tensor, weight: Optional[Tensor], bias: Optional[Tensor], running_mean: Optional[Tensor], running_var: Optional[Tensor], training: _bool, momentum: _float, eps: _float, cudnn_enabled: _bool) -> Tuple[Tensor, Tensor, Tensor, Tensor, _int]: ...
|
|||
|
|
def _cast_Byte(input: Tensor, non_blocking: _bool = False) -> Tensor: ...
|
|||
|
|
def _cast_Char(input: Tensor, non_blocking: _bool = False) -> Tensor: ...
|
|||
|
|
def _cast_Double(input: Tensor, non_blocking: _bool = False) -> Tensor: ...
|
|||
|
|
def _cast_Float(input: Tensor, non_blocking: _bool = False) -> Tensor: ...
|
|||
|
|
def _cast_Half(input: Tensor, non_blocking: _bool = False) -> Tensor: ...
|
|||
|
|
def _cast_Int(input: Tensor, non_blocking: _bool = False) -> Tensor: ...
|
|||
|
|
def _cast_Long(input: Tensor, non_blocking: _bool = False) -> Tensor: ...
|
|||
|
|
def _cast_Short(input: Tensor, non_blocking: _bool = False) -> Tensor: ...
|
|||
|
|
def _choose_qparams_per_tensor(input: Tensor, reduce_range: _bool = False) -> Tuple[_float, _int]: ...
|
|||
|
|
def _chunk_cat(tensors: Union[Tuple[Tensor, ...], List[Tensor]], dim: _int, num_chunks: _int, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _coalesce(input: Tensor) -> Tensor: ...
|
|||
|
|
def _compute_linear_combination(input: Tensor, coefficients: Tensor, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _conj(input: Tensor) -> Tensor: ...
|
|||
|
|
def _conj_copy(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _conj_physical(input: Tensor) -> Tensor: ...
|
|||
|
|
def _convert_indices_from_coo_to_csr(input: Tensor, size: _int, *, out_int32: _bool = False, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _convert_indices_from_csr_to_coo(crow_indices: Tensor, col_indices: Tensor, *, out_int32: _bool = False, transpose: _bool = False, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _convert_weight_to_int4pack(input: Tensor, innerKTiles: _int) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def _convolution(input: Tensor, weight: Tensor, bias: Optional[Tensor], stride: Sequence[Union[_int, SymInt]], padding: Sequence[Union[_int, SymInt]], dilation: Sequence[Union[_int, SymInt]], transposed: _bool, output_padding: _size, groups: Union[_int, SymInt], benchmark: _bool, deterministic: _bool, cudnn_enabled: _bool) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def _convolution(input: Tensor, weight: Tensor, bias: Optional[Tensor], stride: Sequence[Union[_int, SymInt]], padding: Sequence[Union[_int, SymInt]], dilation: Sequence[Union[_int, SymInt]], transposed: _bool, output_padding: Sequence[Union[_int, SymInt]], groups: Union[_int, SymInt], benchmark: _bool, deterministic: _bool, cudnn_enabled: _bool, allow_tf32: _bool) -> Tensor: ...
|
|||
|
|
def _convolution_mode(input: Tensor, weight: Tensor, bias: Optional[Tensor], stride: Sequence[Union[_int, SymInt]], padding: str, dilation: Sequence[Union[_int, SymInt]], groups: Union[_int, SymInt]) -> Tensor: ...
|
|||
|
|
def _copy_from(input: Tensor, dst: Tensor, non_blocking: _bool = False) -> Tensor: ...
|
|||
|
|
def _copy_from_and_resize(input: Tensor, dst: Tensor) -> Tensor: ...
|
|||
|
|
def _cslt_compress(input: Tensor) -> Tensor: ...
|
|||
|
|
def _cslt_sparse_mm(compressed_A: Tensor, dense_B: Tensor, bias: Optional[Tensor] = None, alpha: Optional[Tensor] = None, out_dtype: Optional[_dtype] = None, transpose_result: _bool = False, alg_id: _int = 0) -> Tensor: ...
|
|||
|
|
def _cslt_sparse_mm_search(compressed_A: Tensor, dense_B: Tensor, bias: Optional[Tensor] = None, alpha: Optional[Tensor] = None, out_dtype: Optional[_dtype] = None, transpose_result: _bool = False) -> _int: ...
|
|||
|
|
@overload
|
|||
|
|
def _ctc_loss(log_probs: Tensor, targets: Tensor, input_lengths: _size, target_lengths: _size, blank: _int = 0, zero_infinity: _bool = False) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
@overload
|
|||
|
|
def _ctc_loss(log_probs: Tensor, targets: Tensor, input_lengths: Tensor, target_lengths: Tensor, blank: _int = 0, zero_infinity: _bool = False) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
@overload
|
|||
|
|
def _cudnn_ctc_loss(log_probs: Tensor, targets: Tensor, input_lengths: _size, target_lengths: _size, blank: _int, deterministic: _bool, zero_infinity: _bool) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
@overload
|
|||
|
|
def _cudnn_ctc_loss(log_probs: Tensor, targets: Tensor, input_lengths: Tensor, target_lengths: Tensor, blank: _int, deterministic: _bool, zero_infinity: _bool) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def _cudnn_init_dropout_state(dropout: _float, train: _bool, dropout_seed: _int, *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor: ...
|
|||
|
|
def _cudnn_rnn(input: Tensor, weight: Union[Tuple[Tensor, ...], List[Tensor]], weight_stride0: _int, weight_buf: Optional[Tensor], hx: Tensor, cx: Optional[Tensor], mode: _int, hidden_size: Union[_int, SymInt], proj_size: Union[_int, SymInt], num_layers: _int, batch_first: _bool, dropout: _float, train: _bool, bidirectional: _bool, batch_sizes: Sequence[Union[_int, SymInt]], dropout_state: Optional[Tensor]) -> Tuple[Tensor, Tensor, Tensor, Tensor, Tensor]: ...
|
|||
|
|
def _cudnn_rnn_flatten_weight(weight_arr: Union[Tuple[Tensor, ...], List[Tensor]], weight_stride0: _int, input_size: Union[_int, SymInt], mode: _int, hidden_size: Union[_int, SymInt], proj_size: Union[_int, SymInt], num_layers: _int, batch_first: _bool, bidirectional: _bool) -> Tensor: ...
|
|||
|
|
def _cufft_clear_plan_cache(device_index: _int) -> None: ...
|
|||
|
|
def _cufft_get_plan_cache_max_size(device_index: _int) -> _int: ...
|
|||
|
|
def _cufft_get_plan_cache_size(device_index: _int) -> _int: ...
|
|||
|
|
def _cufft_set_plan_cache_max_size(device_index: _int, max_size: _int) -> None: ...
|
|||
|
|
def _cummax_helper(input: Tensor, values: Tensor, indices: Tensor, dim: _int) -> None: ...
|
|||
|
|
def _cummin_helper(input: Tensor, values: Tensor, indices: Tensor, dim: _int) -> None: ...
|
|||
|
|
def _debug_has_internal_overlap(input: Tensor) -> _int: ...
|
|||
|
|
def _dim_arange(like: Tensor, dim: _int) -> Tensor: ...
|
|||
|
|
def _dirichlet_grad(x: Tensor, alpha: Tensor, total: Tensor) -> Tensor: ...
|
|||
|
|
def _disable_functionalization(): ...
|
|||
|
|
@overload
|
|||
|
|
def _efficientzerotensor(size: Sequence[Union[_int, SymInt]], *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def _efficientzerotensor(*size: _int, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor: ...
|
|||
|
|
def _embedding_bag(weight: Tensor, indices: Tensor, offsets: Tensor, scale_grad_by_freq: _bool = False, mode: _int = 0, sparse: _bool = False, per_sample_weights: Optional[Tensor] = None, include_last_offset: _bool = False, padding_idx: _int = -1) -> Tuple[Tensor, Tensor, Tensor, Tensor]: ...
|
|||
|
|
def _embedding_bag_forward_only(weight: Tensor, indices: Tensor, offsets: Tensor, scale_grad_by_freq: _bool = False, mode: _int = 0, sparse: _bool = False, per_sample_weights: Optional[Tensor] = None, include_last_offset: _bool = False, padding_idx: _int = -1) -> Tuple[Tensor, Tensor, Tensor, Tensor]: ...
|
|||
|
|
@overload
|
|||
|
|
def _empty_affine_quantized(size: Sequence[Union[_int, SymInt]], *, scale: _float = 1, zero_point: _int = 0, memory_format: Optional[memory_format] = contiguous_format, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def _empty_affine_quantized(*size: _int, scale: _float = 1, zero_point: _int = 0, memory_format: Optional[memory_format] = contiguous_format, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def _empty_per_channel_affine_quantized(size: Sequence[Union[_int, SymInt]], *, scales: Tensor, zero_points: Tensor, axis: _int, memory_format: Optional[memory_format] = contiguous_format, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def _empty_per_channel_affine_quantized(*size: _int, scales: Tensor, zero_points: Tensor, axis: _int, memory_format: Optional[memory_format] = contiguous_format, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor: ...
|
|||
|
|
def _enable_functionalization(*, reapply_views: _bool = False): ...
|
|||
|
|
def _euclidean_dist(x1: Tensor, x2: Tensor) -> Tensor: ...
|
|||
|
|
def _fake_quantize_learnable_per_channel_affine(input: Tensor, scale: Tensor, zero_point: Tensor, axis: _int, quant_min: _int, quant_max: _int, grad_factor: _float = 1.0) -> Tensor: ...
|
|||
|
|
def _fake_quantize_learnable_per_tensor_affine(input: Tensor, scale: Tensor, zero_point: Tensor, quant_min: _int, quant_max: _int, grad_factor: _float = 1.0) -> Tensor: ...
|
|||
|
|
def _fake_quantize_per_tensor_affine_cachemask_tensor_qparams(input: Tensor, scale: Tensor, zero_point: Tensor, fake_quant_enabled: Tensor, quant_min: _int, quant_max: _int) -> torch.return_types._fake_quantize_per_tensor_affine_cachemask_tensor_qparams: ...
|
|||
|
|
def _fft_c2c(input: Tensor, dim: Sequence[Union[_int, SymInt]], normalization: _int, forward: _bool, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _fft_c2r(input: Tensor, dim: _size, normalization: _int, last_dim_size: Union[_int, SymInt], *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _fft_r2c(input: Tensor, dim: _size, normalization: _int, onesided: _bool, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _fill_mem_eff_dropout_mask_(input: Tensor, dropout_p: _float, seed: _int, offset: _int) -> Tensor: ...
|
|||
|
|
def _foobar(input: Tensor, arg1: _bool = True, arg2: _bool = True, *, arg3: _bool = True) -> Tensor: ...
|
|||
|
|
def _foreach_abs(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_abs(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.abs` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_abs_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_abs_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.abs` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_acos(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_acos(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.acos` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_acos_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_acos_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.acos` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_add(self: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Sequence[Union[Number, _complex]]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_add(self: Union[Tuple[Tensor, ...], List[Tensor]], other: Union[Tuple[Tensor, ...], List[Tensor]], *, alpha: Union[Number, _complex] = 1) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_add(self: Union[Tuple[Tensor, ...], List[Tensor]], other: Tensor, *, alpha: Union[Number, _complex] = 1) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_add(self: Union[Tuple[Tensor, ...], List[Tensor]], scalar: Union[Number, _complex]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_add_(self: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Sequence[Union[Number, _complex]]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_add_(self: Union[Tuple[Tensor, ...], List[Tensor]], other: Union[Tuple[Tensor, ...], List[Tensor]], *, alpha: Union[Number, _complex] = 1) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_add_(self: Union[Tuple[Tensor, ...], List[Tensor]], other: Tensor, *, alpha: Union[Number, _complex] = 1) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_add_(self: Union[Tuple[Tensor, ...], List[Tensor]], scalar: Union[Number, _complex]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_addcdiv(self: Union[Tuple[Tensor, ...], List[Tensor]], tensor1: Union[Tuple[Tensor, ...], List[Tensor]], tensor2: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Sequence[Union[Number, _complex]]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_addcdiv(self: Union[Tuple[Tensor, ...], List[Tensor]], tensor1: Union[Tuple[Tensor, ...], List[Tensor]], tensor2: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Tensor) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_addcdiv(self: Union[Tuple[Tensor, ...], List[Tensor]], tensor1: Union[Tuple[Tensor, ...], List[Tensor]], tensor2: Union[Tuple[Tensor, ...], List[Tensor]], value: Union[Number, _complex] = 1) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_addcdiv_(self: Union[Tuple[Tensor, ...], List[Tensor]], tensor1: Union[Tuple[Tensor, ...], List[Tensor]], tensor2: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Sequence[Union[Number, _complex]]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_addcdiv_(self: Union[Tuple[Tensor, ...], List[Tensor]], tensor1: Union[Tuple[Tensor, ...], List[Tensor]], tensor2: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Tensor) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_addcdiv_(self: Union[Tuple[Tensor, ...], List[Tensor]], tensor1: Union[Tuple[Tensor, ...], List[Tensor]], tensor2: Union[Tuple[Tensor, ...], List[Tensor]], value: Union[Number, _complex] = 1) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_addcmul(self: Union[Tuple[Tensor, ...], List[Tensor]], tensor1: Union[Tuple[Tensor, ...], List[Tensor]], tensor2: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Sequence[Union[Number, _complex]]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_addcmul(self: Union[Tuple[Tensor, ...], List[Tensor]], tensor1: Union[Tuple[Tensor, ...], List[Tensor]], tensor2: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Tensor) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_addcmul(self: Union[Tuple[Tensor, ...], List[Tensor]], tensor1: Union[Tuple[Tensor, ...], List[Tensor]], tensor2: Union[Tuple[Tensor, ...], List[Tensor]], value: Union[Number, _complex] = 1) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_addcmul_(self: Union[Tuple[Tensor, ...], List[Tensor]], tensor1: Union[Tuple[Tensor, ...], List[Tensor]], tensor2: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Sequence[Union[Number, _complex]]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_addcmul_(self: Union[Tuple[Tensor, ...], List[Tensor]], tensor1: Union[Tuple[Tensor, ...], List[Tensor]], tensor2: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Tensor) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_addcmul_(self: Union[Tuple[Tensor, ...], List[Tensor]], tensor1: Union[Tuple[Tensor, ...], List[Tensor]], tensor2: Union[Tuple[Tensor, ...], List[Tensor]], value: Union[Number, _complex] = 1) -> None: ...
|
|||
|
|
def _foreach_asin(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_asin(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.asin` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_asin_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_asin_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.asin` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_atan(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_atan(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.atan` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_atan_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_atan_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.atan` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_ceil(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_ceil(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.ceil` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_ceil_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_ceil_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.ceil` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_clamp_max(self: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Sequence[Union[Number, _complex]]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_clamp_max(self: Union[Tuple[Tensor, ...], List[Tensor]], scalar: Union[Number, _complex]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_clamp_max(self: Union[Tuple[Tensor, ...], List[Tensor]], other: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_clamp_max_(self: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Sequence[Union[Number, _complex]]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_clamp_max_(self: Union[Tuple[Tensor, ...], List[Tensor]], scalar: Union[Number, _complex]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_clamp_max_(self: Union[Tuple[Tensor, ...], List[Tensor]], other: Union[Tuple[Tensor, ...], List[Tensor]]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_clamp_min(self: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Sequence[Union[Number, _complex]]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_clamp_min(self: Union[Tuple[Tensor, ...], List[Tensor]], scalar: Union[Number, _complex]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_clamp_min(self: Union[Tuple[Tensor, ...], List[Tensor]], other: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_clamp_min_(self: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Sequence[Union[Number, _complex]]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_clamp_min_(self: Union[Tuple[Tensor, ...], List[Tensor]], scalar: Union[Number, _complex]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_clamp_min_(self: Union[Tuple[Tensor, ...], List[Tensor]], other: Union[Tuple[Tensor, ...], List[Tensor]]) -> None: ...
|
|||
|
|
def _foreach_copy_(self: Union[Tuple[Tensor, ...], List[Tensor]], src: Union[Tuple[Tensor, ...], List[Tensor]], non_blocking: _bool = False) -> None: ...
|
|||
|
|
def _foreach_cos(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_cos(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.cos` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_cos_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_cos_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.cos` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_cosh(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_cosh(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.cosh` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_cosh_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_cosh_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.cosh` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_div(self: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Sequence[Union[Number, _complex]]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_div(self: Union[Tuple[Tensor, ...], List[Tensor]], other: Tensor) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_div(self: Union[Tuple[Tensor, ...], List[Tensor]], scalar: Union[Number, _complex]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_div(self: Union[Tuple[Tensor, ...], List[Tensor]], other: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_div_(self: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Sequence[Union[Number, _complex]]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_div_(self: Union[Tuple[Tensor, ...], List[Tensor]], other: Tensor) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_div_(self: Union[Tuple[Tensor, ...], List[Tensor]], scalar: Union[Number, _complex]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_div_(self: Union[Tuple[Tensor, ...], List[Tensor]], other: Union[Tuple[Tensor, ...], List[Tensor]]) -> None: ...
|
|||
|
|
def _foreach_erf(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_erf(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.erf` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_erf_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_erf_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.erf` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_erfc(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_erfc(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.erfc` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_erfc_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_erfc_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.erfc` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_exp(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_exp(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.exp` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_exp_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_exp_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.exp` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_expm1(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_expm1(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.expm1` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_expm1_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_expm1_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.expm1` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_floor(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_floor(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.floor` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_floor_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_floor_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.floor` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_frac(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_frac(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.frac` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_frac_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_frac_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.frac` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_lerp(self: Union[Tuple[Tensor, ...], List[Tensor]], tensors1: Union[Tuple[Tensor, ...], List[Tensor]], weight: Union[Number, _complex]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_lerp(self: Union[Tuple[Tensor, ...], List[Tensor]], tensors1: Union[Tuple[Tensor, ...], List[Tensor]], weights: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_lerp_(self: Union[Tuple[Tensor, ...], List[Tensor]], tensors1: Union[Tuple[Tensor, ...], List[Tensor]], weight: Union[Number, _complex]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_lerp_(self: Union[Tuple[Tensor, ...], List[Tensor]], tensors1: Union[Tuple[Tensor, ...], List[Tensor]], weights: Union[Tuple[Tensor, ...], List[Tensor]]) -> None: ...
|
|||
|
|
def _foreach_lgamma(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_lgamma(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.lgamma` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_lgamma_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_lgamma_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.lgamma` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_log(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_log(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.log` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_log10(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_log10(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.log10` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_log10_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_log10_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.log10` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_log1p(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_log1p(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.log1p` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_log1p_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_log1p_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.log1p` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_log2(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_log2(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.log2` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_log2_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_log2_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.log2` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_log_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_log_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.log` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_maximum(self: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Sequence[Union[Number, _complex]]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_maximum(self: Union[Tuple[Tensor, ...], List[Tensor]], scalar: Union[Number, _complex]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_maximum(self: Union[Tuple[Tensor, ...], List[Tensor]], other: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_maximum_(self: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Sequence[Union[Number, _complex]]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_maximum_(self: Union[Tuple[Tensor, ...], List[Tensor]], scalar: Union[Number, _complex]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_maximum_(self: Union[Tuple[Tensor, ...], List[Tensor]], other: Union[Tuple[Tensor, ...], List[Tensor]]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_minimum(self: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Sequence[Union[Number, _complex]]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_minimum(self: Union[Tuple[Tensor, ...], List[Tensor]], scalar: Union[Number, _complex]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_minimum(self: Union[Tuple[Tensor, ...], List[Tensor]], other: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_minimum_(self: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Sequence[Union[Number, _complex]]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_minimum_(self: Union[Tuple[Tensor, ...], List[Tensor]], scalar: Union[Number, _complex]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_minimum_(self: Union[Tuple[Tensor, ...], List[Tensor]], other: Union[Tuple[Tensor, ...], List[Tensor]]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_mul(self: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Sequence[Union[Number, _complex]]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_mul(self: Union[Tuple[Tensor, ...], List[Tensor]], other: Tensor) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_mul(self: Union[Tuple[Tensor, ...], List[Tensor]], scalar: Union[Number, _complex]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_mul(self: Union[Tuple[Tensor, ...], List[Tensor]], other: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_mul_(self: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Sequence[Union[Number, _complex]]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_mul_(self: Union[Tuple[Tensor, ...], List[Tensor]], other: Tensor) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_mul_(self: Union[Tuple[Tensor, ...], List[Tensor]], scalar: Union[Number, _complex]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_mul_(self: Union[Tuple[Tensor, ...], List[Tensor]], other: Union[Tuple[Tensor, ...], List[Tensor]]) -> None: ...
|
|||
|
|
def _foreach_neg(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_neg(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.neg` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_neg_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_neg_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.neg` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_norm(self: Union[Tuple[Tensor, ...], List[Tensor]], ord: Union[Number, _complex] = 2) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_pow(self: Union[Tuple[Tensor, ...], List[Tensor]], exponent: Sequence[Union[Number, _complex]]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_pow(self: Union[Tuple[Tensor, ...], List[Tensor]], exponent: Union[Number, _complex]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_pow(self: Union[Tuple[Tensor, ...], List[Tensor]], exponent: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_pow(self: Union[Number, _complex], exponent: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_pow_(self: Union[Tuple[Tensor, ...], List[Tensor]], exponent: Sequence[Union[Number, _complex]]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_pow_(self: Union[Tuple[Tensor, ...], List[Tensor]], exponent: Union[Number, _complex]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_pow_(self: Union[Tuple[Tensor, ...], List[Tensor]], exponent: Union[Tuple[Tensor, ...], List[Tensor]]) -> None: ...
|
|||
|
|
def _foreach_reciprocal(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_reciprocal(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.reciprocal` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_reciprocal_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_reciprocal_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.reciprocal` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_round(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_round(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.round` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_round_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_round_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.round` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_sigmoid(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_sigmoid(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.sigmoid` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_sigmoid_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_sigmoid_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.sigmoid` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_sign(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
def _foreach_sign_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None: ...
|
|||
|
|
def _foreach_sin(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_sin(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.sin` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_sin_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_sin_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.sin` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_sinh(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_sinh(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.sinh` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_sinh_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_sinh_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.sinh` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_sqrt(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_sqrt(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.sqrt` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_sqrt_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_sqrt_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.sqrt` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_sub(self: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Sequence[Union[Number, _complex]]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_sub(self: Union[Tuple[Tensor, ...], List[Tensor]], other: Union[Tuple[Tensor, ...], List[Tensor]], *, alpha: Union[Number, _complex] = 1) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_sub(self: Union[Tuple[Tensor, ...], List[Tensor]], scalar: Union[Number, _complex]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_sub_(self: Union[Tuple[Tensor, ...], List[Tensor]], scalars: Sequence[Union[Number, _complex]]) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_sub_(self: Union[Tuple[Tensor, ...], List[Tensor]], other: Union[Tuple[Tensor, ...], List[Tensor]], *, alpha: Union[Number, _complex] = 1) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _foreach_sub_(self: Union[Tuple[Tensor, ...], List[Tensor]], scalar: Union[Number, _complex]) -> None: ...
|
|||
|
|
def _foreach_tan(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_tan(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.tan` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_tan_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_tan_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.tan` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_tanh(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_tanh(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.tanh` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_tanh_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_tanh_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.tanh` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_trunc(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
_foreach_trunc(self: List[Tensor]) -> List[Tensor]
|
|||
|
|
|
|||
|
|
Apply :func:`torch.trunc` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_trunc_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_trunc_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.trunc` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _foreach_zero_(self: Union[Tuple[Tensor, ...], List[Tensor]]) -> None:
|
|||
|
|
r"""
|
|||
|
|
_foreach_zero_(self: List[Tensor]) -> None
|
|||
|
|
|
|||
|
|
Apply :func:`torch.zero` to each Tensor of the input list.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def _from_functional_tensor(t: Tensor) -> Tensor: ...
|
|||
|
|
def _functional_assert_async(input: Tensor, assert_msg: str, dep_token: Tensor) -> Tensor: ...
|
|||
|
|
def _functional_assert_scalar(self: Union[Number, _complex], assert_msg: str, dep_token: Tensor) -> Tensor: ...
|
|||
|
|
def _functional_sym_constrain_range(size: Union[Number, _complex], min: Optional[_int], max: Optional[_int], dep_token: Tensor) -> Tensor: ...
|
|||
|
|
def _functional_sym_constrain_range_for_size(size: Union[Number, _complex], min: Optional[_int], max: Optional[_int], dep_token: Tensor) -> Tensor: ...
|
|||
|
|
def _functionalize_are_all_mutations_hidden_from_autograd(t: Tensor) -> _bool: ...
|
|||
|
|
def _functionalize_are_all_mutations_under_no_grad_or_inference_mode(t: Tensor) -> _bool: ...
|
|||
|
|
def _functionalize_commit_update(t: Tensor) -> None: ...
|
|||
|
|
def _functionalize_mark_mutation_hidden_from_autograd(t: Tensor) -> None: ...
|
|||
|
|
def _functionalize_replace(self_: Tensor, other: Tensor) -> None: ...
|
|||
|
|
def _functionalize_sync(t: Tensor) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _fused_adam_(self: Union[Tuple[Tensor, ...], List[Tensor]], grads: Union[Tuple[Tensor, ...], List[Tensor]], exp_avgs: Union[Tuple[Tensor, ...], List[Tensor]], exp_avg_sqs: Union[Tuple[Tensor, ...], List[Tensor]], max_exp_avg_sqs: Union[Tuple[Tensor, ...], List[Tensor]], state_steps: Union[Tuple[Tensor, ...], List[Tensor]], *, lr: Tensor, beta1: _float, beta2: _float, weight_decay: _float, eps: _float, amsgrad: _bool, maximize: _bool, grad_scale: Optional[Tensor] = None, found_inf: Optional[Tensor] = None) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _fused_adam_(self: Union[Tuple[Tensor, ...], List[Tensor]], grads: Union[Tuple[Tensor, ...], List[Tensor]], exp_avgs: Union[Tuple[Tensor, ...], List[Tensor]], exp_avg_sqs: Union[Tuple[Tensor, ...], List[Tensor]], max_exp_avg_sqs: Union[Tuple[Tensor, ...], List[Tensor]], state_steps: Union[Tuple[Tensor, ...], List[Tensor]], *, lr: _float, beta1: _float, beta2: _float, weight_decay: _float, eps: _float, amsgrad: _bool, maximize: _bool, grad_scale: Optional[Tensor] = None, found_inf: Optional[Tensor] = None) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _fused_adamw_(self: Union[Tuple[Tensor, ...], List[Tensor]], grads: Union[Tuple[Tensor, ...], List[Tensor]], exp_avgs: Union[Tuple[Tensor, ...], List[Tensor]], exp_avg_sqs: Union[Tuple[Tensor, ...], List[Tensor]], max_exp_avg_sqs: Union[Tuple[Tensor, ...], List[Tensor]], state_steps: Union[Tuple[Tensor, ...], List[Tensor]], *, lr: Tensor, beta1: _float, beta2: _float, weight_decay: _float, eps: _float, amsgrad: _bool, maximize: _bool, grad_scale: Optional[Tensor] = None, found_inf: Optional[Tensor] = None) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _fused_adamw_(self: Union[Tuple[Tensor, ...], List[Tensor]], grads: Union[Tuple[Tensor, ...], List[Tensor]], exp_avgs: Union[Tuple[Tensor, ...], List[Tensor]], exp_avg_sqs: Union[Tuple[Tensor, ...], List[Tensor]], max_exp_avg_sqs: Union[Tuple[Tensor, ...], List[Tensor]], state_steps: Union[Tuple[Tensor, ...], List[Tensor]], *, lr: _float, beta1: _float, beta2: _float, weight_decay: _float, eps: _float, amsgrad: _bool, maximize: _bool, grad_scale: Optional[Tensor] = None, found_inf: Optional[Tensor] = None) -> None: ...
|
|||
|
|
def _fused_dropout(input: Tensor, p: _float, generator: Optional[Generator] = None) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def _fused_moving_avg_obs_fq_helper(input: Tensor, observer_on: Tensor, fake_quant_on: Tensor, running_min: Tensor, running_max: Tensor, scale: Tensor, zero_point: Tensor, averaging_const: _float, quant_min: _int, quant_max: _int, ch_axis: _int, per_row_fake_quant: _bool = False, symmetric_quant: _bool = False) -> torch.return_types._fused_moving_avg_obs_fq_helper: ...
|
|||
|
|
def _fused_sdp_choice(query: Tensor, key: Tensor, value: Tensor, attn_mask: Optional[Tensor] = None, dropout_p: _float = 0.0, is_causal: _bool = False, *, scale: Optional[_float] = None) -> _int: ...
|
|||
|
|
@overload
|
|||
|
|
def _fused_sgd_(self: Union[Tuple[Tensor, ...], List[Tensor]], grads: Union[Tuple[Tensor, ...], List[Tensor]], momentum_buffer_list: Union[Tuple[Tensor, ...], List[Tensor]], *, weight_decay: _float, momentum: _float, lr: Tensor, dampening: _float, nesterov: _bool, maximize: _bool, is_first_step: _bool, grad_scale: Optional[Tensor] = None, found_inf: Optional[Tensor] = None) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _fused_sgd_(self: Union[Tuple[Tensor, ...], List[Tensor]], grads: Union[Tuple[Tensor, ...], List[Tensor]], momentum_buffer_list: Union[Tuple[Tensor, ...], List[Tensor]], *, weight_decay: _float, momentum: _float, lr: _float, dampening: _float, nesterov: _bool, maximize: _bool, is_first_step: _bool, grad_scale: Optional[Tensor] = None, found_inf: Optional[Tensor] = None) -> None: ...
|
|||
|
|
def _fw_primal_copy(input: Tensor, level: _int, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _grid_sampler_2d_cpu_fallback(input: Tensor, grid: Tensor, interpolation_mode: _int, padding_mode: _int, align_corners: _bool) -> Tensor: ...
|
|||
|
|
def _has_compatible_shallow_copy_type(input: Tensor, from_: Tensor) -> _bool: ...
|
|||
|
|
def _histogramdd_bin_edges(input: Tensor, bins: _size, *, range: Optional[Sequence[_float]] = None, weight: Optional[Tensor] = None, density: _bool = False) -> Tuple[Tensor, ...]: ...
|
|||
|
|
def _histogramdd_from_bin_cts(input: Tensor, bins: _size, *, range: Optional[Sequence[_float]] = None, weight: Optional[Tensor] = None, density: _bool = False) -> Tensor: ...
|
|||
|
|
def _histogramdd_from_bin_tensors(input: Tensor, bins: Union[Tuple[Tensor, ...], List[Tensor]], *, weight: Optional[Tensor] = None, density: _bool = False) -> Tensor: ...
|
|||
|
|
def _index_put_impl_(input: Tensor, indices: Optional[Union[Tuple[Tensor, ...], List[Tensor]]], values: Tensor, accumulate: _bool = False, unsafe: _bool = False) -> Tensor: ...
|
|||
|
|
def _indices_copy(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _int_mm(input: Tensor, mat2: Tensor, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _is_all_true(input: Tensor) -> Tensor: ...
|
|||
|
|
def _is_any_true(input: Tensor) -> Tensor: ...
|
|||
|
|
def _is_functional_tensor(t: Tensor) -> _bool: ...
|
|||
|
|
def _is_zerotensor(input: Tensor) -> _bool: ...
|
|||
|
|
def _lazy_clone(input: Tensor) -> Tensor: ...
|
|||
|
|
def _linalg_check_errors(info: Tensor, api_name: str, *, is_matrix: _bool) -> None: ...
|
|||
|
|
def _linalg_det(A: Tensor, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types._linalg_det: ...
|
|||
|
|
def _linalg_eigh(A: Tensor, UPLO: str = "L", compute_v: _bool = True, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types._linalg_eigh: ...
|
|||
|
|
def _linalg_slogdet(A: Tensor, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types._linalg_slogdet: ...
|
|||
|
|
def _linalg_solve_ex(A: Tensor, B: Tensor, *, left: _bool = True, check_errors: _bool = False, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types._linalg_solve_ex: ...
|
|||
|
|
def _linalg_svd(A: Tensor, full_matrices: _bool = False, compute_uv: _bool = True, *, driver: Optional[str] = None, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types._linalg_svd: ...
|
|||
|
|
def _log_softmax(input: Tensor, dim: _int, half_to_float: _bool, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _log_softmax_backward_data(grad_output: Tensor, output: Tensor, dim: _int, input_dtype: _dtype, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _logcumsumexp(input: Tensor, dim: _int, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _lstm_mps(input: Tensor, hx: Union[Tuple[Tensor, ...], List[Tensor]], params: Union[Tuple[Tensor, ...], List[Tensor]], has_biases: _bool, num_layers: _int, dropout: _float, train: _bool, bidirectional: _bool, batch_first: _bool) -> Tuple[Tensor, Tensor, Tensor, Tensor, Tensor, Tensor]: ...
|
|||
|
|
def _lu_with_info(input: Tensor, pivot: _bool = True, check_errors: _bool = True) -> torch.return_types._lu_with_info: ...
|
|||
|
|
def _make_dep_token(*, memory_format: Optional[memory_format] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor: ...
|
|||
|
|
def _make_dual(primal: Tensor, tangent: Tensor, level: _int) -> Tensor: ...
|
|||
|
|
def _make_dual_copy(primal: Tensor, tangent: Tensor, level: _int, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _make_per_channel_quantized_tensor(input: Tensor, scale: Tensor, zero_point: Tensor, axis: _int) -> Tensor: ...
|
|||
|
|
def _make_per_tensor_quantized_tensor(input: Tensor, scale: _float, zero_point: _int) -> Tensor: ...
|
|||
|
|
def _masked_scale(input: Tensor, mask: Tensor, scale: _float) -> Tensor: ...
|
|||
|
|
def _masked_softmax(input: Tensor, mask: Tensor, dim: Optional[_int] = None, mask_type: Optional[_int] = None) -> Tensor: ...
|
|||
|
|
def _mixed_dtypes_linear(input: Tensor, weight: Tensor, scale: Tensor, *, bias: Optional[Tensor] = None, activation: Optional[str] = None) -> Tensor: ...
|
|||
|
|
def _mkldnn_reshape(input: Tensor, shape: _size) -> Tensor: ...
|
|||
|
|
def _mkldnn_transpose(input: Tensor, dim0: _int, dim1: _int) -> Tensor: ...
|
|||
|
|
def _mkldnn_transpose_(input: Tensor, dim0: _int, dim1: _int) -> Tensor: ...
|
|||
|
|
def _mps_convolution(input: Tensor, weight: Tensor, bias: Optional[Tensor], padding: Sequence[Union[_int, SymInt]], stride: Sequence[Union[_int, SymInt]], dilation: Sequence[Union[_int, SymInt]], groups: Union[_int, SymInt]) -> Tensor: ...
|
|||
|
|
def _mps_convolution_transpose(input: Tensor, weight: Tensor, padding: Sequence[Union[_int, SymInt]], output_padding: Sequence[Union[_int, SymInt]], stride: Sequence[Union[_int, SymInt]], dilation: Sequence[Union[_int, SymInt]], groups: Union[_int, SymInt]) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def _native_batch_norm_legit(input: Tensor, weight: Optional[Tensor], bias: Optional[Tensor], running_mean: Tensor, running_var: Tensor, training: _bool, momentum: _float, eps: _float, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> Tuple[Tensor, Tensor, Tensor]: ...
|
|||
|
|
@overload
|
|||
|
|
def _native_batch_norm_legit(input: Tensor, weight: Optional[Tensor], bias: Optional[Tensor], training: _bool, momentum: _float, eps: _float, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> Tuple[Tensor, Tensor, Tensor]: ...
|
|||
|
|
def _native_batch_norm_legit_no_training(input: Tensor, weight: Optional[Tensor], bias: Optional[Tensor], running_mean: Tensor, running_var: Tensor, momentum: _float, eps: _float) -> Tuple[Tensor, Tensor, Tensor]: ...
|
|||
|
|
def _native_multi_head_attention(query: Tensor, key: Tensor, value: Tensor, embed_dim: _int, num_head: _int, qkv_weight: Tensor, qkv_bias: Tensor, proj_weight: Tensor, proj_bias: Tensor, mask: Optional[Tensor] = None, need_weights: _bool = True, average_attn_weights: _bool = True, mask_type: Optional[_int] = None) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def _neg_view(input: Tensor) -> Tensor: ...
|
|||
|
|
def _neg_view_copy(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _nested_from_padded(padded: Tensor, cpu_nested_shape_example: Tensor, fuse_transform_0213: _bool = False) -> Tensor: ...
|
|||
|
|
def _nested_from_padded_and_nested_example(padded: Tensor, nt_example: Tensor) -> Tensor: ...
|
|||
|
|
def _nested_get_jagged_dummy(any: Tensor) -> Tensor: ...
|
|||
|
|
def _nested_get_lengths(input: Tensor) -> Tensor: ...
|
|||
|
|
def _nested_get_offsets(input: Tensor) -> Tensor: ...
|
|||
|
|
def _nested_get_ragged_idx(input: Tensor) -> _int: ...
|
|||
|
|
def _nested_get_values(input: Tensor) -> Tensor: ...
|
|||
|
|
def _nested_get_values_copy(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _nested_tensor_from_mask(t: Tensor, mask: Tensor, mask_check: _bool = True) -> Tensor: ...
|
|||
|
|
def _nested_tensor_from_mask_left_aligned(t: Tensor, mask: Tensor) -> _bool: ...
|
|||
|
|
def _nested_tensor_from_tensor_list(list: Union[Tuple[Tensor, ...], List[Tensor]], dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = None) -> Tensor: ...
|
|||
|
|
def _nested_tensor_softmax_with_shape(input: Tensor, query: Tensor) -> Tensor: ...
|
|||
|
|
def _nested_view_from_buffer(input: Tensor, nested_size: Tensor, nested_strides: Tensor, offsets: Tensor) -> Tensor: ...
|
|||
|
|
def _nested_view_from_buffer_copy(input: Tensor, nested_size: Tensor, nested_strides: Tensor, offsets: Tensor, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _nested_view_from_jagged(input: Tensor, offsets: Tensor, dummy: Tensor, lengths: Optional[Tensor] = None, ragged_idx: _int = 1) -> Tensor: ...
|
|||
|
|
def _nested_view_from_jagged_copy(input: Tensor, offsets: Tensor, dummy: Tensor, lengths: Optional[Tensor] = None, ragged_idx: _int = 1, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _nnpack_available() -> _bool: ...
|
|||
|
|
def _nnpack_spatial_convolution(input: Tensor, weight: Tensor, bias: Optional[Tensor], padding: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]], stride: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 1) -> Tensor: ...
|
|||
|
|
def _pack_padded_sequence(input: Tensor, lengths: Tensor, batch_first: _bool) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def _pad_packed_sequence(data: Tensor, batch_sizes: Tensor, batch_first: _bool, padding_value: Union[Number, _complex], total_length: _int) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def _pin_memory(input: Tensor, device: Optional[Optional[DeviceLikeType]] = None) -> Tensor: ...
|
|||
|
|
def _prelu_kernel(input: Tensor, weight: Tensor) -> Tensor: ...
|
|||
|
|
def _print(s: str) -> None: ...
|
|||
|
|
def _propagate_xla_data(input: Tensor, output: Tensor) -> None: ...
|
|||
|
|
def _remove_batch_dim(input: Tensor, level: _int, batch_size: _int, out_dim: _int) -> Tensor: ...
|
|||
|
|
def _reshape_alias_copy(input: Tensor, size: Sequence[Union[_int, SymInt]], stride: Sequence[Union[_int, SymInt]], *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _reshape_from_tensor(input: Tensor, shape: Tensor) -> Tensor: ...
|
|||
|
|
def _resize_output_(input: Tensor, size: Sequence[Union[_int, SymInt]], device: Optional[DeviceLikeType]) -> Tensor: ...
|
|||
|
|
def _rowwise_prune(weight: Tensor, mask: Tensor, compressed_indices_dtype: _dtype) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def _sample_dirichlet(input: Tensor, generator: Optional[Generator] = None) -> Tensor: ...
|
|||
|
|
def _saturate_weight_to_fp16(weight: Tensor) -> Tensor: ...
|
|||
|
|
def _scaled_dot_product_attention_math(query: Tensor, key: Tensor, value: Tensor, attn_mask: Optional[Tensor] = None, dropout_p: _float = 0.0, is_causal: _bool = False, dropout_mask: Optional[Tensor] = None, *, scale: Optional[_float] = None) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def _scaled_dot_product_cudnn_attention(query: Tensor, key: Tensor, value: Tensor, dropout_p: _float = 0.0, is_causal: _bool = False, return_debug_mask: _bool = False, *, scale: Optional[_float] = None) -> torch.return_types._scaled_dot_product_cudnn_attention: ...
|
|||
|
|
def _scaled_dot_product_efficient_attention(query: Tensor, key: Tensor, value: Tensor, attn_bias: Optional[Tensor], compute_log_sumexp: _bool, dropout_p: _float = 0.0, is_causal: _bool = False, *, scale: Optional[_float] = None) -> torch.return_types._scaled_dot_product_efficient_attention: ...
|
|||
|
|
def _scaled_dot_product_flash_attention(query: Tensor, key: Tensor, value: Tensor, dropout_p: _float = 0.0, is_causal: _bool = False, return_debug_mask: _bool = False, *, scale: Optional[_float] = None) -> torch.return_types._scaled_dot_product_flash_attention: ...
|
|||
|
|
def _scaled_dot_product_flash_attention_for_cpu(query: Tensor, key: Tensor, value: Tensor, dropout_p: _float = 0.0, is_causal: _bool = False, *, attn_mask: Optional[Tensor] = None, scale: Optional[_float] = None) -> torch.return_types._scaled_dot_product_flash_attention_for_cpu: ...
|
|||
|
|
def _scaled_mm(input: Tensor, mat2: Tensor, *, bias: Optional[Tensor] = None, out_dtype: Optional[_dtype] = None, scale_a: Optional[Tensor] = None, scale_b: Optional[Tensor] = None, scale_result: Optional[Tensor] = None, use_fast_accum: _bool = False, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def _shape_as_tensor(input: Tensor) -> Tensor: ...
|
|||
|
|
def _sobol_engine_draw(quasi: Tensor, n: _int, sobolstate: Tensor, dimension: _int, num_generated: _int, dtype: Optional[_dtype]) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def _sobol_engine_ff_(input: Tensor, n: _int, sobolstate: Tensor, dimension: _int, num_generated: _int) -> Tensor: ...
|
|||
|
|
def _sobol_engine_initialize_state_(input: Tensor, dimension: _int) -> Tensor: ...
|
|||
|
|
def _sobol_engine_scramble_(input: Tensor, ltm: Tensor, dimension: _int) -> Tensor: ...
|
|||
|
|
def _softmax(input: Tensor, dim: _int, half_to_float: _bool, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _softmax_backward_data(grad_output: Tensor, output: Tensor, dim: _int, input_dtype: _dtype, *, grad_input: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _sparse_broadcast_to(input: Tensor, size: _size) -> Tensor: ...
|
|||
|
|
def _sparse_broadcast_to_copy(input: Tensor, size: _size, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _sparse_csr_prod(input: Tensor, dim: Union[_int, _size], keepdim: _bool = False, *, dtype: Optional[_dtype] = None) -> Tensor: ...
|
|||
|
|
def _sparse_csr_sum(input: Tensor, dim: Union[_int, _size], keepdim: _bool = False, *, dtype: Optional[_dtype] = None) -> Tensor: ...
|
|||
|
|
def _sparse_log_softmax_backward_data(grad_output: Tensor, output: Tensor, dim: _int, input: Tensor) -> Tensor: ...
|
|||
|
|
def _sparse_semi_structured_linear(input: Tensor, weight: Tensor, meta: Tensor, *, bias: Optional[Tensor] = None, activation: Optional[str] = None, out_dtype: Optional[_dtype] = None) -> Tensor: ...
|
|||
|
|
def _sparse_softmax_backward_data(grad_output: Tensor, output: Tensor, dim: _int, input: Tensor) -> Tensor: ...
|
|||
|
|
def _sparse_sparse_matmul(input: Tensor, other: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def _sparse_sum(input: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def _sparse_sum(input: Tensor, *, dtype: _dtype) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def _sparse_sum(input: Tensor, dim: Union[_int, _size]) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def _sparse_sum(input: Tensor, dim: Union[_int, _size], *, dtype: _dtype) -> Tensor: ...
|
|||
|
|
def _stack(tensors: Union[Tuple[Tensor, ...], List[Tensor]], dim: _int = 0, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _standard_gamma(input: Tensor, generator: Optional[Generator] = None) -> Tensor: ...
|
|||
|
|
def _standard_gamma_grad(input: Tensor, output: Tensor) -> Tensor: ...
|
|||
|
|
def _sync(t: Tensor) -> None: ...
|
|||
|
|
@overload
|
|||
|
|
def _test_autograd_multiple_dispatch(input: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def _test_autograd_multiple_dispatch(input: Tensor, b: _bool) -> Tensor: ...
|
|||
|
|
def _test_autograd_multiple_dispatch_view(input: Tensor) -> Tensor: ...
|
|||
|
|
def _test_autograd_multiple_dispatch_view_copy(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _test_check_tensor(input: Tensor) -> Tensor: ...
|
|||
|
|
def _test_functorch_fallback(input: Tensor, other: Tensor) -> Tensor: ...
|
|||
|
|
def _test_parallel_materialize(input: Tensor, num_parallel: _int, skip_first: _bool = False) -> Tensor: ...
|
|||
|
|
def _test_serialization_subcmul(input: Tensor, other: Tensor, alpha: Union[Number, _complex] = 1) -> Tensor: ...
|
|||
|
|
def _to_cpu(tensors: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]: ...
|
|||
|
|
def _to_functional_tensor(t: Tensor) -> Tensor: ...
|
|||
|
|
def _to_sparse_semi_structured(dense: Tensor) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def _transform_bias_rescale_qkv(qkv: Tensor, qkv_bias: Tensor, num_heads: _int) -> Tuple[Tensor, Tensor, Tensor]: ...
|
|||
|
|
def _transformer_encoder_layer_fwd(src: Tensor, embed_dim: _int, num_heads: _int, qkv_weight: Tensor, qkv_bias: Tensor, proj_weight: Tensor, proj_bias: Tensor, use_gelu: _bool, norm_first: _bool, eps: _float, norm_weight_1: Tensor, norm_bias_1: Tensor, norm_weight_2: Tensor, norm_bias_2: Tensor, ffn_weight_1: Tensor, ffn_bias_1: Tensor, ffn_weight_2: Tensor, ffn_bias_2: Tensor, mask: Optional[Tensor] = None, mask_type: Optional[_int] = None) -> Tensor: ...
|
|||
|
|
def _trilinear(i1: Tensor, i2: Tensor, i3: Tensor, expand1: _size, expand2: _size, expand3: _size, sumdim: _size, unroll_dim: _int = 1) -> Tensor: ...
|
|||
|
|
def _triton_multi_head_attention(query: Tensor, key: Tensor, value: Tensor, embed_dim: _int, num_head: _int, qkv_weight: Tensor, qkv_bias: Tensor, proj_weight: Tensor, proj_bias: Tensor, mask: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _triton_scaled_dot_attention(q: Tensor, k: Tensor, v: Tensor, dropout_p: _float = 0.0) -> Tensor: ...
|
|||
|
|
def _unique(input: Tensor, sorted: _bool = True, return_inverse: _bool = False) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def _unique2(input: Tensor, sorted: _bool = True, return_inverse: _bool = False, return_counts: _bool = False) -> Tuple[Tensor, Tensor, Tensor]: ...
|
|||
|
|
def _unpack_dual(dual: Tensor, level: _int) -> torch.return_types._unpack_dual: ...
|
|||
|
|
def _unsafe_index(input: Tensor, indices: Optional[Union[Tuple[Tensor, ...], List[Tensor]]]) -> Tensor: ...
|
|||
|
|
def _unsafe_index_put(input: Tensor, indices: Optional[Union[Tuple[Tensor, ...], List[Tensor]]], values: Tensor, accumulate: _bool = False) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def _use_cudnn_ctc_loss(log_probs: Tensor, targets: Tensor, input_lengths: Tensor, target_lengths: Tensor, blank: _int) -> _bool: ...
|
|||
|
|
@overload
|
|||
|
|
def _use_cudnn_ctc_loss(log_probs: Tensor, targets: Tensor, input_lengths: _size, target_lengths: _size, blank: _int) -> _bool: ...
|
|||
|
|
def _use_cudnn_rnn_flatten_weight() -> _bool: ...
|
|||
|
|
def _validate_compressed_sparse_indices(is_crow: _bool, compressed_idx: Tensor, plain_idx: Tensor, cdim: _int, dim: _int, nnz: _int) -> None: ...
|
|||
|
|
def _validate_sparse_bsc_tensor_args(ccol_indices: Tensor, row_indices: Tensor, values: Tensor, size: _size) -> None: ...
|
|||
|
|
def _validate_sparse_bsr_tensor_args(crow_indices: Tensor, col_indices: Tensor, values: Tensor, size: _size) -> None: ...
|
|||
|
|
def _validate_sparse_compressed_tensor_args(compressed_indices: Tensor, plain_indices: Tensor, values: Tensor, size: _size, layout: _layout) -> None: ...
|
|||
|
|
def _validate_sparse_coo_tensor_args(indices: Tensor, values: Tensor, size: _size, is_coalesced: Optional[_bool] = None) -> None: ...
|
|||
|
|
def _validate_sparse_csc_tensor_args(ccol_indices: Tensor, row_indices: Tensor, values: Tensor, size: _size) -> None: ...
|
|||
|
|
def _validate_sparse_csr_tensor_args(crow_indices: Tensor, col_indices: Tensor, values: Tensor, size: _size) -> None: ...
|
|||
|
|
def _values_copy(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def _weight_int4pack_mm(input: Tensor, mat2: Tensor, qGroupSize: _int, qScaleAndZeros: Tensor) -> Tensor: ...
|
|||
|
|
def _weight_int8pack_mm(input: Tensor, mat2: Tensor, scales: Tensor) -> Tensor: ...
|
|||
|
|
def _weight_norm(v: Tensor, g: Tensor, dim: _int = 0) -> Tensor: ...
|
|||
|
|
def _weight_norm_interface(v: Tensor, g: Tensor, dim: _int = 0) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def abs(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
abs(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the absolute value of each element in :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = |\text{input}_{i}|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.abs(torch.tensor([-1, -2, 3]))
|
|||
|
|
tensor([ 1, 2, 3])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def abs_(input: Tensor) -> Tensor: ...
|
|||
|
|
def absolute(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
absolute(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.abs`
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def acos(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
acos(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the inverse cosine of each element in :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \cos^{-1}(\text{input}_{i})
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 0.3348, -0.5889, 0.2005, -0.1584])
|
|||
|
|
>>> torch.acos(a)
|
|||
|
|
tensor([ 1.2294, 2.2004, 1.3690, 1.7298])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def acos_(input: Tensor) -> Tensor: ...
|
|||
|
|
def acosh(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
acosh(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the inverse hyperbolic cosine of the elements of :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \cosh^{-1}(\text{input}_{i})
|
|||
|
|
|
|||
|
|
Note:
|
|||
|
|
The domain of the inverse hyperbolic cosine is `[1, inf)` and values outside this range
|
|||
|
|
will be mapped to ``NaN``, except for `+ INF` for which the output is mapped to `+ INF`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4).uniform_(1, 2)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 1.3192, 1.9915, 1.9674, 1.7151 ])
|
|||
|
|
>>> torch.acosh(a)
|
|||
|
|
tensor([ 0.7791, 1.3120, 1.2979, 1.1341 ])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def acosh_(input: Tensor) -> Tensor: ...
|
|||
|
|
def adaptive_avg_pool1d(input: Tensor, output_size: Union[_int, _size]) -> Tensor: ...
|
|||
|
|
def adaptive_max_pool1d(input: Tensor, output_size: Union[_int, _size]) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
@overload
|
|||
|
|
def add(input: Union[Tensor, Number, _complex], other: Union[Tensor, Number, _complex], *, alpha: Optional[Union[Number, _complex]] = 1, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
add(input, other, *, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Adds :attr:`other`, scaled by :attr:`alpha`, to :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{{out}}_i = \text{{input}}_i + \text{{alpha}} \times \text{{other}}_i
|
|||
|
|
|
|||
|
|
|
|||
|
|
Supports :ref:`broadcasting to a common shape <broadcasting-semantics>`,
|
|||
|
|
:ref:`type promotion <type-promotion-doc>`, and integer, float, and complex inputs.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
other (Tensor or Number): the tensor or number to add to :attr:`input`.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
alpha (Number): the multiplier for :attr:`other`.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 0.0202, 1.0985, 1.3506, -0.6056])
|
|||
|
|
>>> torch.add(a, 20)
|
|||
|
|
tensor([ 20.0202, 21.0985, 21.3506, 19.3944])
|
|||
|
|
|
|||
|
|
>>> b = torch.randn(4)
|
|||
|
|
>>> b
|
|||
|
|
tensor([-0.9732, -0.3497, 0.6245, 0.4022])
|
|||
|
|
>>> c = torch.randn(4, 1)
|
|||
|
|
>>> c
|
|||
|
|
tensor([[ 0.3743],
|
|||
|
|
[-1.7724],
|
|||
|
|
[-0.5811],
|
|||
|
|
[-0.8017]])
|
|||
|
|
>>> torch.add(b, c, alpha=10)
|
|||
|
|
tensor([[ 2.7695, 3.3930, 4.3672, 4.1450],
|
|||
|
|
[-18.6971, -18.0736, -17.0994, -17.3216],
|
|||
|
|
[ -6.7845, -6.1610, -5.1868, -5.4090],
|
|||
|
|
[ -8.9902, -8.3667, -7.3925, -7.6147]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def add(self: Tensor, alpha: Union[Number, _complex], other: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
add(input, other, *, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Adds :attr:`other`, scaled by :attr:`alpha`, to :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{{out}}_i = \text{{input}}_i + \text{{alpha}} \times \text{{other}}_i
|
|||
|
|
|
|||
|
|
|
|||
|
|
Supports :ref:`broadcasting to a common shape <broadcasting-semantics>`,
|
|||
|
|
:ref:`type promotion <type-promotion-doc>`, and integer, float, and complex inputs.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
other (Tensor or Number): the tensor or number to add to :attr:`input`.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
alpha (Number): the multiplier for :attr:`other`.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 0.0202, 1.0985, 1.3506, -0.6056])
|
|||
|
|
>>> torch.add(a, 20)
|
|||
|
|
tensor([ 20.0202, 21.0985, 21.3506, 19.3944])
|
|||
|
|
|
|||
|
|
>>> b = torch.randn(4)
|
|||
|
|
>>> b
|
|||
|
|
tensor([-0.9732, -0.3497, 0.6245, 0.4022])
|
|||
|
|
>>> c = torch.randn(4, 1)
|
|||
|
|
>>> c
|
|||
|
|
tensor([[ 0.3743],
|
|||
|
|
[-1.7724],
|
|||
|
|
[-0.5811],
|
|||
|
|
[-0.8017]])
|
|||
|
|
>>> torch.add(b, c, alpha=10)
|
|||
|
|
tensor([[ 2.7695, 3.3930, 4.3672, 4.1450],
|
|||
|
|
[-18.6971, -18.0736, -17.0994, -17.3216],
|
|||
|
|
[ -6.7845, -6.1610, -5.1868, -5.4090],
|
|||
|
|
[ -8.9902, -8.3667, -7.3925, -7.6147]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def add(self: Tensor, alpha: Union[Number, _complex], other: Tensor, *, out: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
add(input, other, *, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Adds :attr:`other`, scaled by :attr:`alpha`, to :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{{out}}_i = \text{{input}}_i + \text{{alpha}} \times \text{{other}}_i
|
|||
|
|
|
|||
|
|
|
|||
|
|
Supports :ref:`broadcasting to a common shape <broadcasting-semantics>`,
|
|||
|
|
:ref:`type promotion <type-promotion-doc>`, and integer, float, and complex inputs.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
other (Tensor or Number): the tensor or number to add to :attr:`input`.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
alpha (Number): the multiplier for :attr:`other`.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 0.0202, 1.0985, 1.3506, -0.6056])
|
|||
|
|
>>> torch.add(a, 20)
|
|||
|
|
tensor([ 20.0202, 21.0985, 21.3506, 19.3944])
|
|||
|
|
|
|||
|
|
>>> b = torch.randn(4)
|
|||
|
|
>>> b
|
|||
|
|
tensor([-0.9732, -0.3497, 0.6245, 0.4022])
|
|||
|
|
>>> c = torch.randn(4, 1)
|
|||
|
|
>>> c
|
|||
|
|
tensor([[ 0.3743],
|
|||
|
|
[-1.7724],
|
|||
|
|
[-0.5811],
|
|||
|
|
[-0.8017]])
|
|||
|
|
>>> torch.add(b, c, alpha=10)
|
|||
|
|
tensor([[ 2.7695, 3.3930, 4.3672, 4.1450],
|
|||
|
|
[-18.6971, -18.0736, -17.0994, -17.3216],
|
|||
|
|
[ -6.7845, -6.1610, -5.1868, -5.4090],
|
|||
|
|
[ -8.9902, -8.3667, -7.3925, -7.6147]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addbmm(beta: Union[Number, _complex], self: Tensor, alpha: Union[Number, _complex], batch1: Tensor, batch2: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addbmm(input, batch1, batch2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a batch matrix-matrix product of matrices stored
|
|||
|
|
in :attr:`batch1` and :attr:`batch2`,
|
|||
|
|
with a reduced add step (all matrix multiplications get accumulated
|
|||
|
|
along the first dimension).
|
|||
|
|
:attr:`input` is added to the final result.
|
|||
|
|
|
|||
|
|
:attr:`batch1` and :attr:`batch2` must be 3-D tensors each containing the
|
|||
|
|
same number of matrices.
|
|||
|
|
|
|||
|
|
If :attr:`batch1` is a :math:`(b \times n \times m)` tensor, :attr:`batch2` is a
|
|||
|
|
:math:`(b \times m \times p)` tensor, :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a :math:`(n \times p)` tensor
|
|||
|
|
and :attr:`out` will be a :math:`(n \times p)` tensor.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
out = \beta\ \text{input} + \alpha\ (\sum_{i=0}^{b-1} \text{batch1}_i \mathbin{@} \text{batch2}_i)
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, arguments :attr:`beta` and :attr:`alpha`
|
|||
|
|
must be real numbers, otherwise they should be integers.
|
|||
|
|
|
|||
|
|
This operator supports :ref:`TensorFloat32<tf32_on_ampere>`.
|
|||
|
|
|
|||
|
|
On certain ROCm devices, when using float16 inputs this module will use :ref:`different precision<fp16_on_mi200>` for backward.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
batch1 (Tensor): the first batch of matrices to be multiplied
|
|||
|
|
batch2 (Tensor): the second batch of matrices to be multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
input (Tensor): matrix to be added
|
|||
|
|
alpha (Number, optional): multiplier for `batch1 @ batch2` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> M = torch.randn(3, 5)
|
|||
|
|
>>> batch1 = torch.randn(10, 3, 4)
|
|||
|
|
>>> batch2 = torch.randn(10, 4, 5)
|
|||
|
|
>>> torch.addbmm(M, batch1, batch2)
|
|||
|
|
tensor([[ 6.6311, 0.0503, 6.9768, -12.0362, -2.1653],
|
|||
|
|
[ -4.8185, -1.4255, -6.6760, 8.9453, 2.5743],
|
|||
|
|
[ -3.8202, 4.3691, 1.0943, -1.1109, 5.4730]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addbmm(beta: Union[Number, _complex], self: Tensor, alpha: Union[Number, _complex], batch1: Tensor, batch2: Tensor, *, out: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addbmm(input, batch1, batch2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a batch matrix-matrix product of matrices stored
|
|||
|
|
in :attr:`batch1` and :attr:`batch2`,
|
|||
|
|
with a reduced add step (all matrix multiplications get accumulated
|
|||
|
|
along the first dimension).
|
|||
|
|
:attr:`input` is added to the final result.
|
|||
|
|
|
|||
|
|
:attr:`batch1` and :attr:`batch2` must be 3-D tensors each containing the
|
|||
|
|
same number of matrices.
|
|||
|
|
|
|||
|
|
If :attr:`batch1` is a :math:`(b \times n \times m)` tensor, :attr:`batch2` is a
|
|||
|
|
:math:`(b \times m \times p)` tensor, :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a :math:`(n \times p)` tensor
|
|||
|
|
and :attr:`out` will be a :math:`(n \times p)` tensor.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
out = \beta\ \text{input} + \alpha\ (\sum_{i=0}^{b-1} \text{batch1}_i \mathbin{@} \text{batch2}_i)
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, arguments :attr:`beta` and :attr:`alpha`
|
|||
|
|
must be real numbers, otherwise they should be integers.
|
|||
|
|
|
|||
|
|
This operator supports :ref:`TensorFloat32<tf32_on_ampere>`.
|
|||
|
|
|
|||
|
|
On certain ROCm devices, when using float16 inputs this module will use :ref:`different precision<fp16_on_mi200>` for backward.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
batch1 (Tensor): the first batch of matrices to be multiplied
|
|||
|
|
batch2 (Tensor): the second batch of matrices to be multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
input (Tensor): matrix to be added
|
|||
|
|
alpha (Number, optional): multiplier for `batch1 @ batch2` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> M = torch.randn(3, 5)
|
|||
|
|
>>> batch1 = torch.randn(10, 3, 4)
|
|||
|
|
>>> batch2 = torch.randn(10, 4, 5)
|
|||
|
|
>>> torch.addbmm(M, batch1, batch2)
|
|||
|
|
tensor([[ 6.6311, 0.0503, 6.9768, -12.0362, -2.1653],
|
|||
|
|
[ -4.8185, -1.4255, -6.6760, 8.9453, 2.5743],
|
|||
|
|
[ -3.8202, 4.3691, 1.0943, -1.1109, 5.4730]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addbmm(input: Tensor, batch1: Tensor, batch2: Tensor, *, beta: Union[Number, _complex] = 1, alpha: Union[Number, _complex] = 1, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addbmm(input, batch1, batch2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a batch matrix-matrix product of matrices stored
|
|||
|
|
in :attr:`batch1` and :attr:`batch2`,
|
|||
|
|
with a reduced add step (all matrix multiplications get accumulated
|
|||
|
|
along the first dimension).
|
|||
|
|
:attr:`input` is added to the final result.
|
|||
|
|
|
|||
|
|
:attr:`batch1` and :attr:`batch2` must be 3-D tensors each containing the
|
|||
|
|
same number of matrices.
|
|||
|
|
|
|||
|
|
If :attr:`batch1` is a :math:`(b \times n \times m)` tensor, :attr:`batch2` is a
|
|||
|
|
:math:`(b \times m \times p)` tensor, :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a :math:`(n \times p)` tensor
|
|||
|
|
and :attr:`out` will be a :math:`(n \times p)` tensor.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
out = \beta\ \text{input} + \alpha\ (\sum_{i=0}^{b-1} \text{batch1}_i \mathbin{@} \text{batch2}_i)
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, arguments :attr:`beta` and :attr:`alpha`
|
|||
|
|
must be real numbers, otherwise they should be integers.
|
|||
|
|
|
|||
|
|
This operator supports :ref:`TensorFloat32<tf32_on_ampere>`.
|
|||
|
|
|
|||
|
|
On certain ROCm devices, when using float16 inputs this module will use :ref:`different precision<fp16_on_mi200>` for backward.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
batch1 (Tensor): the first batch of matrices to be multiplied
|
|||
|
|
batch2 (Tensor): the second batch of matrices to be multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
input (Tensor): matrix to be added
|
|||
|
|
alpha (Number, optional): multiplier for `batch1 @ batch2` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> M = torch.randn(3, 5)
|
|||
|
|
>>> batch1 = torch.randn(10, 3, 4)
|
|||
|
|
>>> batch2 = torch.randn(10, 4, 5)
|
|||
|
|
>>> torch.addbmm(M, batch1, batch2)
|
|||
|
|
tensor([[ 6.6311, 0.0503, 6.9768, -12.0362, -2.1653],
|
|||
|
|
[ -4.8185, -1.4255, -6.6760, 8.9453, 2.5743],
|
|||
|
|
[ -3.8202, 4.3691, 1.0943, -1.1109, 5.4730]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addbmm(beta: Union[Number, _complex], self: Tensor, batch1: Tensor, batch2: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addbmm(input, batch1, batch2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a batch matrix-matrix product of matrices stored
|
|||
|
|
in :attr:`batch1` and :attr:`batch2`,
|
|||
|
|
with a reduced add step (all matrix multiplications get accumulated
|
|||
|
|
along the first dimension).
|
|||
|
|
:attr:`input` is added to the final result.
|
|||
|
|
|
|||
|
|
:attr:`batch1` and :attr:`batch2` must be 3-D tensors each containing the
|
|||
|
|
same number of matrices.
|
|||
|
|
|
|||
|
|
If :attr:`batch1` is a :math:`(b \times n \times m)` tensor, :attr:`batch2` is a
|
|||
|
|
:math:`(b \times m \times p)` tensor, :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a :math:`(n \times p)` tensor
|
|||
|
|
and :attr:`out` will be a :math:`(n \times p)` tensor.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
out = \beta\ \text{input} + \alpha\ (\sum_{i=0}^{b-1} \text{batch1}_i \mathbin{@} \text{batch2}_i)
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, arguments :attr:`beta` and :attr:`alpha`
|
|||
|
|
must be real numbers, otherwise they should be integers.
|
|||
|
|
|
|||
|
|
This operator supports :ref:`TensorFloat32<tf32_on_ampere>`.
|
|||
|
|
|
|||
|
|
On certain ROCm devices, when using float16 inputs this module will use :ref:`different precision<fp16_on_mi200>` for backward.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
batch1 (Tensor): the first batch of matrices to be multiplied
|
|||
|
|
batch2 (Tensor): the second batch of matrices to be multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
input (Tensor): matrix to be added
|
|||
|
|
alpha (Number, optional): multiplier for `batch1 @ batch2` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> M = torch.randn(3, 5)
|
|||
|
|
>>> batch1 = torch.randn(10, 3, 4)
|
|||
|
|
>>> batch2 = torch.randn(10, 4, 5)
|
|||
|
|
>>> torch.addbmm(M, batch1, batch2)
|
|||
|
|
tensor([[ 6.6311, 0.0503, 6.9768, -12.0362, -2.1653],
|
|||
|
|
[ -4.8185, -1.4255, -6.6760, 8.9453, 2.5743],
|
|||
|
|
[ -3.8202, 4.3691, 1.0943, -1.1109, 5.4730]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addbmm(beta: Union[Number, _complex], self: Tensor, batch1: Tensor, batch2: Tensor, *, out: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addbmm(input, batch1, batch2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a batch matrix-matrix product of matrices stored
|
|||
|
|
in :attr:`batch1` and :attr:`batch2`,
|
|||
|
|
with a reduced add step (all matrix multiplications get accumulated
|
|||
|
|
along the first dimension).
|
|||
|
|
:attr:`input` is added to the final result.
|
|||
|
|
|
|||
|
|
:attr:`batch1` and :attr:`batch2` must be 3-D tensors each containing the
|
|||
|
|
same number of matrices.
|
|||
|
|
|
|||
|
|
If :attr:`batch1` is a :math:`(b \times n \times m)` tensor, :attr:`batch2` is a
|
|||
|
|
:math:`(b \times m \times p)` tensor, :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a :math:`(n \times p)` tensor
|
|||
|
|
and :attr:`out` will be a :math:`(n \times p)` tensor.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
out = \beta\ \text{input} + \alpha\ (\sum_{i=0}^{b-1} \text{batch1}_i \mathbin{@} \text{batch2}_i)
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, arguments :attr:`beta` and :attr:`alpha`
|
|||
|
|
must be real numbers, otherwise they should be integers.
|
|||
|
|
|
|||
|
|
This operator supports :ref:`TensorFloat32<tf32_on_ampere>`.
|
|||
|
|
|
|||
|
|
On certain ROCm devices, when using float16 inputs this module will use :ref:`different precision<fp16_on_mi200>` for backward.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
batch1 (Tensor): the first batch of matrices to be multiplied
|
|||
|
|
batch2 (Tensor): the second batch of matrices to be multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
input (Tensor): matrix to be added
|
|||
|
|
alpha (Number, optional): multiplier for `batch1 @ batch2` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> M = torch.randn(3, 5)
|
|||
|
|
>>> batch1 = torch.randn(10, 3, 4)
|
|||
|
|
>>> batch2 = torch.randn(10, 4, 5)
|
|||
|
|
>>> torch.addbmm(M, batch1, batch2)
|
|||
|
|
tensor([[ 6.6311, 0.0503, 6.9768, -12.0362, -2.1653],
|
|||
|
|
[ -4.8185, -1.4255, -6.6760, 8.9453, 2.5743],
|
|||
|
|
[ -3.8202, 4.3691, 1.0943, -1.1109, 5.4730]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addcdiv(self: Tensor, value: Union[Number, _complex], tensor1: Tensor, tensor2: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addcdiv(input, tensor1, tensor2, *, value=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs the element-wise division of :attr:`tensor1` by :attr:`tensor2`,
|
|||
|
|
multiplies the result by the scalar :attr:`value` and adds it to :attr:`input`.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
Integer division with addcdiv is no longer supported, and in a future
|
|||
|
|
release addcdiv will perform a true division of tensor1 and tensor2.
|
|||
|
|
The historic addcdiv behavior can be implemented as
|
|||
|
|
(input + value * torch.trunc(tensor1 / tensor2)).to(input.dtype)
|
|||
|
|
for integer inputs and as (input + value * tensor1 / tensor2) for float inputs.
|
|||
|
|
The future addcdiv behavior is just the latter implementation:
|
|||
|
|
(input + value * tensor1 / tensor2), for all dtypes.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \text{input}_i + \text{value} \times \frac{\text{tensor1}_i}{\text{tensor2}_i}
|
|||
|
|
|
|||
|
|
|
|||
|
|
The shapes of :attr:`input`, :attr:`tensor1`, and :attr:`tensor2` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, :attr:`value` must be
|
|||
|
|
a real number, otherwise an integer.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to be added
|
|||
|
|
tensor1 (Tensor): the numerator tensor
|
|||
|
|
tensor2 (Tensor): the denominator tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
value (Number, optional): multiplier for :math:`\text{tensor1} / \text{tensor2}`
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> t = torch.randn(1, 3)
|
|||
|
|
>>> t1 = torch.randn(3, 1)
|
|||
|
|
>>> t2 = torch.randn(1, 3)
|
|||
|
|
>>> torch.addcdiv(t, t1, t2, value=0.1)
|
|||
|
|
tensor([[-0.2312, -3.6496, 0.1312],
|
|||
|
|
[-1.0428, 3.4292, -0.1030],
|
|||
|
|
[-0.5369, -0.9829, 0.0430]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addcdiv(self: Tensor, value: Union[Number, _complex], tensor1: Tensor, tensor2: Tensor, *, out: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addcdiv(input, tensor1, tensor2, *, value=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs the element-wise division of :attr:`tensor1` by :attr:`tensor2`,
|
|||
|
|
multiplies the result by the scalar :attr:`value` and adds it to :attr:`input`.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
Integer division with addcdiv is no longer supported, and in a future
|
|||
|
|
release addcdiv will perform a true division of tensor1 and tensor2.
|
|||
|
|
The historic addcdiv behavior can be implemented as
|
|||
|
|
(input + value * torch.trunc(tensor1 / tensor2)).to(input.dtype)
|
|||
|
|
for integer inputs and as (input + value * tensor1 / tensor2) for float inputs.
|
|||
|
|
The future addcdiv behavior is just the latter implementation:
|
|||
|
|
(input + value * tensor1 / tensor2), for all dtypes.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \text{input}_i + \text{value} \times \frac{\text{tensor1}_i}{\text{tensor2}_i}
|
|||
|
|
|
|||
|
|
|
|||
|
|
The shapes of :attr:`input`, :attr:`tensor1`, and :attr:`tensor2` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, :attr:`value` must be
|
|||
|
|
a real number, otherwise an integer.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to be added
|
|||
|
|
tensor1 (Tensor): the numerator tensor
|
|||
|
|
tensor2 (Tensor): the denominator tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
value (Number, optional): multiplier for :math:`\text{tensor1} / \text{tensor2}`
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> t = torch.randn(1, 3)
|
|||
|
|
>>> t1 = torch.randn(3, 1)
|
|||
|
|
>>> t2 = torch.randn(1, 3)
|
|||
|
|
>>> torch.addcdiv(t, t1, t2, value=0.1)
|
|||
|
|
tensor([[-0.2312, -3.6496, 0.1312],
|
|||
|
|
[-1.0428, 3.4292, -0.1030],
|
|||
|
|
[-0.5369, -0.9829, 0.0430]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addcdiv(input: Tensor, tensor1: Tensor, tensor2: Tensor, *, value: Union[Number, _complex] = 1, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addcdiv(input, tensor1, tensor2, *, value=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs the element-wise division of :attr:`tensor1` by :attr:`tensor2`,
|
|||
|
|
multiplies the result by the scalar :attr:`value` and adds it to :attr:`input`.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
Integer division with addcdiv is no longer supported, and in a future
|
|||
|
|
release addcdiv will perform a true division of tensor1 and tensor2.
|
|||
|
|
The historic addcdiv behavior can be implemented as
|
|||
|
|
(input + value * torch.trunc(tensor1 / tensor2)).to(input.dtype)
|
|||
|
|
for integer inputs and as (input + value * tensor1 / tensor2) for float inputs.
|
|||
|
|
The future addcdiv behavior is just the latter implementation:
|
|||
|
|
(input + value * tensor1 / tensor2), for all dtypes.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \text{input}_i + \text{value} \times \frac{\text{tensor1}_i}{\text{tensor2}_i}
|
|||
|
|
|
|||
|
|
|
|||
|
|
The shapes of :attr:`input`, :attr:`tensor1`, and :attr:`tensor2` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, :attr:`value` must be
|
|||
|
|
a real number, otherwise an integer.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to be added
|
|||
|
|
tensor1 (Tensor): the numerator tensor
|
|||
|
|
tensor2 (Tensor): the denominator tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
value (Number, optional): multiplier for :math:`\text{tensor1} / \text{tensor2}`
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> t = torch.randn(1, 3)
|
|||
|
|
>>> t1 = torch.randn(3, 1)
|
|||
|
|
>>> t2 = torch.randn(1, 3)
|
|||
|
|
>>> torch.addcdiv(t, t1, t2, value=0.1)
|
|||
|
|
tensor([[-0.2312, -3.6496, 0.1312],
|
|||
|
|
[-1.0428, 3.4292, -0.1030],
|
|||
|
|
[-0.5369, -0.9829, 0.0430]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addcmul(self: Tensor, value: Union[Number, _complex], tensor1: Tensor, tensor2: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addcmul(input, tensor1, tensor2, *, value=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs the element-wise multiplication of :attr:`tensor1`
|
|||
|
|
by :attr:`tensor2`, multiplies the result by the scalar :attr:`value`
|
|||
|
|
and adds it to :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \text{input}_i + \text{value} \times \text{tensor1}_i \times \text{tensor2}_i
|
|||
|
|
|
|||
|
|
The shapes of :attr:`tensor`, :attr:`tensor1`, and :attr:`tensor2` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, :attr:`value` must be
|
|||
|
|
a real number, otherwise an integer.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to be added
|
|||
|
|
tensor1 (Tensor): the tensor to be multiplied
|
|||
|
|
tensor2 (Tensor): the tensor to be multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
value (Number, optional): multiplier for :math:`tensor1 .* tensor2`
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> t = torch.randn(1, 3)
|
|||
|
|
>>> t1 = torch.randn(3, 1)
|
|||
|
|
>>> t2 = torch.randn(1, 3)
|
|||
|
|
>>> torch.addcmul(t, t1, t2, value=0.1)
|
|||
|
|
tensor([[-0.8635, -0.6391, 1.6174],
|
|||
|
|
[-0.7617, -0.5879, 1.7388],
|
|||
|
|
[-0.8353, -0.6249, 1.6511]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addcmul(self: Tensor, value: Union[Number, _complex], tensor1: Tensor, tensor2: Tensor, *, out: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addcmul(input, tensor1, tensor2, *, value=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs the element-wise multiplication of :attr:`tensor1`
|
|||
|
|
by :attr:`tensor2`, multiplies the result by the scalar :attr:`value`
|
|||
|
|
and adds it to :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \text{input}_i + \text{value} \times \text{tensor1}_i \times \text{tensor2}_i
|
|||
|
|
|
|||
|
|
The shapes of :attr:`tensor`, :attr:`tensor1`, and :attr:`tensor2` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, :attr:`value` must be
|
|||
|
|
a real number, otherwise an integer.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to be added
|
|||
|
|
tensor1 (Tensor): the tensor to be multiplied
|
|||
|
|
tensor2 (Tensor): the tensor to be multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
value (Number, optional): multiplier for :math:`tensor1 .* tensor2`
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> t = torch.randn(1, 3)
|
|||
|
|
>>> t1 = torch.randn(3, 1)
|
|||
|
|
>>> t2 = torch.randn(1, 3)
|
|||
|
|
>>> torch.addcmul(t, t1, t2, value=0.1)
|
|||
|
|
tensor([[-0.8635, -0.6391, 1.6174],
|
|||
|
|
[-0.7617, -0.5879, 1.7388],
|
|||
|
|
[-0.8353, -0.6249, 1.6511]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addcmul(input: Tensor, tensor1: Tensor, tensor2: Tensor, *, value: Union[Number, _complex] = 1, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addcmul(input, tensor1, tensor2, *, value=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs the element-wise multiplication of :attr:`tensor1`
|
|||
|
|
by :attr:`tensor2`, multiplies the result by the scalar :attr:`value`
|
|||
|
|
and adds it to :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \text{input}_i + \text{value} \times \text{tensor1}_i \times \text{tensor2}_i
|
|||
|
|
|
|||
|
|
The shapes of :attr:`tensor`, :attr:`tensor1`, and :attr:`tensor2` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, :attr:`value` must be
|
|||
|
|
a real number, otherwise an integer.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to be added
|
|||
|
|
tensor1 (Tensor): the tensor to be multiplied
|
|||
|
|
tensor2 (Tensor): the tensor to be multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
value (Number, optional): multiplier for :math:`tensor1 .* tensor2`
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> t = torch.randn(1, 3)
|
|||
|
|
>>> t1 = torch.randn(3, 1)
|
|||
|
|
>>> t2 = torch.randn(1, 3)
|
|||
|
|
>>> torch.addcmul(t, t1, t2, value=0.1)
|
|||
|
|
tensor([[-0.8635, -0.6391, 1.6174],
|
|||
|
|
[-0.7617, -0.5879, 1.7388],
|
|||
|
|
[-0.8353, -0.6249, 1.6511]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addmm(beta: Union[Number, _complex], self: Tensor, alpha: Union[Number, _complex], mat1: Tensor, mat2: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addmm(input, mat1, mat2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a matrix multiplication of the matrices :attr:`mat1` and :attr:`mat2`.
|
|||
|
|
The matrix :attr:`input` is added to the final result.
|
|||
|
|
|
|||
|
|
If :attr:`mat1` is a :math:`(n \times m)` tensor, :attr:`mat2` is a
|
|||
|
|
:math:`(m \times p)` tensor, then :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a :math:`(n \times p)` tensor
|
|||
|
|
and :attr:`out` will be a :math:`(n \times p)` tensor.
|
|||
|
|
|
|||
|
|
:attr:`alpha` and :attr:`beta` are scaling factors on matrix-vector product between
|
|||
|
|
:attr:`mat1` and :attr:`mat2` and the added matrix :attr:`input` respectively.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out} = \beta\ \text{input} + \alpha\ (\text{mat1}_i \mathbin{@} \text{mat2}_i)
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, arguments :attr:`beta` and
|
|||
|
|
:attr:`alpha` must be real numbers, otherwise they should be integers.
|
|||
|
|
|
|||
|
|
This operation has support for arguments with :ref:`sparse layouts<sparse-docs>`. If
|
|||
|
|
:attr:`input` is sparse the result will have the same layout and if :attr:`out`
|
|||
|
|
is provided it must have the same layout as :attr:`input`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
Sparse support is a beta feature and some layout(s)/dtype/device combinations may not be supported,
|
|||
|
|
or may not have autograd support. If you notice missing functionality please
|
|||
|
|
open a feature request.
|
|||
|
|
|
|||
|
|
This operator supports :ref:`TensorFloat32<tf32_on_ampere>`.
|
|||
|
|
|
|||
|
|
On certain ROCm devices, when using float16 inputs this module will use :ref:`different precision<fp16_on_mi200>` for backward.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): matrix to be added
|
|||
|
|
mat1 (Tensor): the first matrix to be matrix multiplied
|
|||
|
|
mat2 (Tensor): the second matrix to be matrix multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`mat1 @ mat2` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> M = torch.randn(2, 3)
|
|||
|
|
>>> mat1 = torch.randn(2, 3)
|
|||
|
|
>>> mat2 = torch.randn(3, 3)
|
|||
|
|
>>> torch.addmm(M, mat1, mat2)
|
|||
|
|
tensor([[-4.8716, 1.4671, -1.3746],
|
|||
|
|
[ 0.7573, -3.9555, -2.8681]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addmm(beta: Union[Number, _complex], self: Tensor, alpha: Union[Number, _complex], mat1: Tensor, mat2: Tensor, *, out: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addmm(input, mat1, mat2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a matrix multiplication of the matrices :attr:`mat1` and :attr:`mat2`.
|
|||
|
|
The matrix :attr:`input` is added to the final result.
|
|||
|
|
|
|||
|
|
If :attr:`mat1` is a :math:`(n \times m)` tensor, :attr:`mat2` is a
|
|||
|
|
:math:`(m \times p)` tensor, then :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a :math:`(n \times p)` tensor
|
|||
|
|
and :attr:`out` will be a :math:`(n \times p)` tensor.
|
|||
|
|
|
|||
|
|
:attr:`alpha` and :attr:`beta` are scaling factors on matrix-vector product between
|
|||
|
|
:attr:`mat1` and :attr:`mat2` and the added matrix :attr:`input` respectively.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out} = \beta\ \text{input} + \alpha\ (\text{mat1}_i \mathbin{@} \text{mat2}_i)
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, arguments :attr:`beta` and
|
|||
|
|
:attr:`alpha` must be real numbers, otherwise they should be integers.
|
|||
|
|
|
|||
|
|
This operation has support for arguments with :ref:`sparse layouts<sparse-docs>`. If
|
|||
|
|
:attr:`input` is sparse the result will have the same layout and if :attr:`out`
|
|||
|
|
is provided it must have the same layout as :attr:`input`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
Sparse support is a beta feature and some layout(s)/dtype/device combinations may not be supported,
|
|||
|
|
or may not have autograd support. If you notice missing functionality please
|
|||
|
|
open a feature request.
|
|||
|
|
|
|||
|
|
This operator supports :ref:`TensorFloat32<tf32_on_ampere>`.
|
|||
|
|
|
|||
|
|
On certain ROCm devices, when using float16 inputs this module will use :ref:`different precision<fp16_on_mi200>` for backward.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): matrix to be added
|
|||
|
|
mat1 (Tensor): the first matrix to be matrix multiplied
|
|||
|
|
mat2 (Tensor): the second matrix to be matrix multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`mat1 @ mat2` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> M = torch.randn(2, 3)
|
|||
|
|
>>> mat1 = torch.randn(2, 3)
|
|||
|
|
>>> mat2 = torch.randn(3, 3)
|
|||
|
|
>>> torch.addmm(M, mat1, mat2)
|
|||
|
|
tensor([[-4.8716, 1.4671, -1.3746],
|
|||
|
|
[ 0.7573, -3.9555, -2.8681]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addmm(input: Tensor, mat1: Tensor, mat2: Tensor, *, beta: Union[Number, _complex] = 1, alpha: Union[Number, _complex] = 1, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addmm(input, mat1, mat2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a matrix multiplication of the matrices :attr:`mat1` and :attr:`mat2`.
|
|||
|
|
The matrix :attr:`input` is added to the final result.
|
|||
|
|
|
|||
|
|
If :attr:`mat1` is a :math:`(n \times m)` tensor, :attr:`mat2` is a
|
|||
|
|
:math:`(m \times p)` tensor, then :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a :math:`(n \times p)` tensor
|
|||
|
|
and :attr:`out` will be a :math:`(n \times p)` tensor.
|
|||
|
|
|
|||
|
|
:attr:`alpha` and :attr:`beta` are scaling factors on matrix-vector product between
|
|||
|
|
:attr:`mat1` and :attr:`mat2` and the added matrix :attr:`input` respectively.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out} = \beta\ \text{input} + \alpha\ (\text{mat1}_i \mathbin{@} \text{mat2}_i)
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, arguments :attr:`beta` and
|
|||
|
|
:attr:`alpha` must be real numbers, otherwise they should be integers.
|
|||
|
|
|
|||
|
|
This operation has support for arguments with :ref:`sparse layouts<sparse-docs>`. If
|
|||
|
|
:attr:`input` is sparse the result will have the same layout and if :attr:`out`
|
|||
|
|
is provided it must have the same layout as :attr:`input`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
Sparse support is a beta feature and some layout(s)/dtype/device combinations may not be supported,
|
|||
|
|
or may not have autograd support. If you notice missing functionality please
|
|||
|
|
open a feature request.
|
|||
|
|
|
|||
|
|
This operator supports :ref:`TensorFloat32<tf32_on_ampere>`.
|
|||
|
|
|
|||
|
|
On certain ROCm devices, when using float16 inputs this module will use :ref:`different precision<fp16_on_mi200>` for backward.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): matrix to be added
|
|||
|
|
mat1 (Tensor): the first matrix to be matrix multiplied
|
|||
|
|
mat2 (Tensor): the second matrix to be matrix multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`mat1 @ mat2` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> M = torch.randn(2, 3)
|
|||
|
|
>>> mat1 = torch.randn(2, 3)
|
|||
|
|
>>> mat2 = torch.randn(3, 3)
|
|||
|
|
>>> torch.addmm(M, mat1, mat2)
|
|||
|
|
tensor([[-4.8716, 1.4671, -1.3746],
|
|||
|
|
[ 0.7573, -3.9555, -2.8681]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addmm(beta: Union[Number, _complex], self: Tensor, mat1: Tensor, mat2: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addmm(input, mat1, mat2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a matrix multiplication of the matrices :attr:`mat1` and :attr:`mat2`.
|
|||
|
|
The matrix :attr:`input` is added to the final result.
|
|||
|
|
|
|||
|
|
If :attr:`mat1` is a :math:`(n \times m)` tensor, :attr:`mat2` is a
|
|||
|
|
:math:`(m \times p)` tensor, then :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a :math:`(n \times p)` tensor
|
|||
|
|
and :attr:`out` will be a :math:`(n \times p)` tensor.
|
|||
|
|
|
|||
|
|
:attr:`alpha` and :attr:`beta` are scaling factors on matrix-vector product between
|
|||
|
|
:attr:`mat1` and :attr:`mat2` and the added matrix :attr:`input` respectively.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out} = \beta\ \text{input} + \alpha\ (\text{mat1}_i \mathbin{@} \text{mat2}_i)
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, arguments :attr:`beta` and
|
|||
|
|
:attr:`alpha` must be real numbers, otherwise they should be integers.
|
|||
|
|
|
|||
|
|
This operation has support for arguments with :ref:`sparse layouts<sparse-docs>`. If
|
|||
|
|
:attr:`input` is sparse the result will have the same layout and if :attr:`out`
|
|||
|
|
is provided it must have the same layout as :attr:`input`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
Sparse support is a beta feature and some layout(s)/dtype/device combinations may not be supported,
|
|||
|
|
or may not have autograd support. If you notice missing functionality please
|
|||
|
|
open a feature request.
|
|||
|
|
|
|||
|
|
This operator supports :ref:`TensorFloat32<tf32_on_ampere>`.
|
|||
|
|
|
|||
|
|
On certain ROCm devices, when using float16 inputs this module will use :ref:`different precision<fp16_on_mi200>` for backward.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): matrix to be added
|
|||
|
|
mat1 (Tensor): the first matrix to be matrix multiplied
|
|||
|
|
mat2 (Tensor): the second matrix to be matrix multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`mat1 @ mat2` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> M = torch.randn(2, 3)
|
|||
|
|
>>> mat1 = torch.randn(2, 3)
|
|||
|
|
>>> mat2 = torch.randn(3, 3)
|
|||
|
|
>>> torch.addmm(M, mat1, mat2)
|
|||
|
|
tensor([[-4.8716, 1.4671, -1.3746],
|
|||
|
|
[ 0.7573, -3.9555, -2.8681]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addmm(beta: Union[Number, _complex], self: Tensor, mat1: Tensor, mat2: Tensor, *, out: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addmm(input, mat1, mat2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a matrix multiplication of the matrices :attr:`mat1` and :attr:`mat2`.
|
|||
|
|
The matrix :attr:`input` is added to the final result.
|
|||
|
|
|
|||
|
|
If :attr:`mat1` is a :math:`(n \times m)` tensor, :attr:`mat2` is a
|
|||
|
|
:math:`(m \times p)` tensor, then :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a :math:`(n \times p)` tensor
|
|||
|
|
and :attr:`out` will be a :math:`(n \times p)` tensor.
|
|||
|
|
|
|||
|
|
:attr:`alpha` and :attr:`beta` are scaling factors on matrix-vector product between
|
|||
|
|
:attr:`mat1` and :attr:`mat2` and the added matrix :attr:`input` respectively.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out} = \beta\ \text{input} + \alpha\ (\text{mat1}_i \mathbin{@} \text{mat2}_i)
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, arguments :attr:`beta` and
|
|||
|
|
:attr:`alpha` must be real numbers, otherwise they should be integers.
|
|||
|
|
|
|||
|
|
This operation has support for arguments with :ref:`sparse layouts<sparse-docs>`. If
|
|||
|
|
:attr:`input` is sparse the result will have the same layout and if :attr:`out`
|
|||
|
|
is provided it must have the same layout as :attr:`input`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
Sparse support is a beta feature and some layout(s)/dtype/device combinations may not be supported,
|
|||
|
|
or may not have autograd support. If you notice missing functionality please
|
|||
|
|
open a feature request.
|
|||
|
|
|
|||
|
|
This operator supports :ref:`TensorFloat32<tf32_on_ampere>`.
|
|||
|
|
|
|||
|
|
On certain ROCm devices, when using float16 inputs this module will use :ref:`different precision<fp16_on_mi200>` for backward.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): matrix to be added
|
|||
|
|
mat1 (Tensor): the first matrix to be matrix multiplied
|
|||
|
|
mat2 (Tensor): the second matrix to be matrix multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`mat1 @ mat2` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> M = torch.randn(2, 3)
|
|||
|
|
>>> mat1 = torch.randn(2, 3)
|
|||
|
|
>>> mat2 = torch.randn(3, 3)
|
|||
|
|
>>> torch.addmm(M, mat1, mat2)
|
|||
|
|
tensor([[-4.8716, 1.4671, -1.3746],
|
|||
|
|
[ 0.7573, -3.9555, -2.8681]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addmv(beta: Union[Number, _complex], self: Tensor, alpha: Union[Number, _complex], mat: Tensor, vec: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addmv(input, mat, vec, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a matrix-vector product of the matrix :attr:`mat` and
|
|||
|
|
the vector :attr:`vec`.
|
|||
|
|
The vector :attr:`input` is added to the final result.
|
|||
|
|
|
|||
|
|
If :attr:`mat` is a :math:`(n \times m)` tensor, :attr:`vec` is a 1-D tensor of
|
|||
|
|
size `m`, then :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a 1-D tensor of size `n` and
|
|||
|
|
:attr:`out` will be 1-D tensor of size `n`.
|
|||
|
|
|
|||
|
|
:attr:`alpha` and :attr:`beta` are scaling factors on matrix-vector product between
|
|||
|
|
:attr:`mat` and :attr:`vec` and the added tensor :attr:`input` respectively.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out} = \beta\ \text{input} + \alpha\ (\text{mat} \mathbin{@} \text{vec})
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, arguments :attr:`beta` and
|
|||
|
|
:attr:`alpha` must be real numbers, otherwise they should be integers.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): vector to be added
|
|||
|
|
mat (Tensor): matrix to be matrix multiplied
|
|||
|
|
vec (Tensor): vector to be matrix multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`mat @ vec` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> M = torch.randn(2)
|
|||
|
|
>>> mat = torch.randn(2, 3)
|
|||
|
|
>>> vec = torch.randn(3)
|
|||
|
|
>>> torch.addmv(M, mat, vec)
|
|||
|
|
tensor([-0.3768, -5.5565])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addmv(beta: Union[Number, _complex], self: Tensor, alpha: Union[Number, _complex], mat: Tensor, vec: Tensor, *, out: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addmv(input, mat, vec, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a matrix-vector product of the matrix :attr:`mat` and
|
|||
|
|
the vector :attr:`vec`.
|
|||
|
|
The vector :attr:`input` is added to the final result.
|
|||
|
|
|
|||
|
|
If :attr:`mat` is a :math:`(n \times m)` tensor, :attr:`vec` is a 1-D tensor of
|
|||
|
|
size `m`, then :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a 1-D tensor of size `n` and
|
|||
|
|
:attr:`out` will be 1-D tensor of size `n`.
|
|||
|
|
|
|||
|
|
:attr:`alpha` and :attr:`beta` are scaling factors on matrix-vector product between
|
|||
|
|
:attr:`mat` and :attr:`vec` and the added tensor :attr:`input` respectively.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out} = \beta\ \text{input} + \alpha\ (\text{mat} \mathbin{@} \text{vec})
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, arguments :attr:`beta` and
|
|||
|
|
:attr:`alpha` must be real numbers, otherwise they should be integers.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): vector to be added
|
|||
|
|
mat (Tensor): matrix to be matrix multiplied
|
|||
|
|
vec (Tensor): vector to be matrix multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`mat @ vec` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> M = torch.randn(2)
|
|||
|
|
>>> mat = torch.randn(2, 3)
|
|||
|
|
>>> vec = torch.randn(3)
|
|||
|
|
>>> torch.addmv(M, mat, vec)
|
|||
|
|
tensor([-0.3768, -5.5565])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addmv(input: Tensor, mat: Tensor, vec: Tensor, *, beta: Union[Number, _complex] = 1, alpha: Union[Number, _complex] = 1, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addmv(input, mat, vec, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a matrix-vector product of the matrix :attr:`mat` and
|
|||
|
|
the vector :attr:`vec`.
|
|||
|
|
The vector :attr:`input` is added to the final result.
|
|||
|
|
|
|||
|
|
If :attr:`mat` is a :math:`(n \times m)` tensor, :attr:`vec` is a 1-D tensor of
|
|||
|
|
size `m`, then :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a 1-D tensor of size `n` and
|
|||
|
|
:attr:`out` will be 1-D tensor of size `n`.
|
|||
|
|
|
|||
|
|
:attr:`alpha` and :attr:`beta` are scaling factors on matrix-vector product between
|
|||
|
|
:attr:`mat` and :attr:`vec` and the added tensor :attr:`input` respectively.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out} = \beta\ \text{input} + \alpha\ (\text{mat} \mathbin{@} \text{vec})
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, arguments :attr:`beta` and
|
|||
|
|
:attr:`alpha` must be real numbers, otherwise they should be integers.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): vector to be added
|
|||
|
|
mat (Tensor): matrix to be matrix multiplied
|
|||
|
|
vec (Tensor): vector to be matrix multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`mat @ vec` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> M = torch.randn(2)
|
|||
|
|
>>> mat = torch.randn(2, 3)
|
|||
|
|
>>> vec = torch.randn(3)
|
|||
|
|
>>> torch.addmv(M, mat, vec)
|
|||
|
|
tensor([-0.3768, -5.5565])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addmv(beta: Union[Number, _complex], self: Tensor, mat: Tensor, vec: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addmv(input, mat, vec, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a matrix-vector product of the matrix :attr:`mat` and
|
|||
|
|
the vector :attr:`vec`.
|
|||
|
|
The vector :attr:`input` is added to the final result.
|
|||
|
|
|
|||
|
|
If :attr:`mat` is a :math:`(n \times m)` tensor, :attr:`vec` is a 1-D tensor of
|
|||
|
|
size `m`, then :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a 1-D tensor of size `n` and
|
|||
|
|
:attr:`out` will be 1-D tensor of size `n`.
|
|||
|
|
|
|||
|
|
:attr:`alpha` and :attr:`beta` are scaling factors on matrix-vector product between
|
|||
|
|
:attr:`mat` and :attr:`vec` and the added tensor :attr:`input` respectively.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out} = \beta\ \text{input} + \alpha\ (\text{mat} \mathbin{@} \text{vec})
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, arguments :attr:`beta` and
|
|||
|
|
:attr:`alpha` must be real numbers, otherwise they should be integers.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): vector to be added
|
|||
|
|
mat (Tensor): matrix to be matrix multiplied
|
|||
|
|
vec (Tensor): vector to be matrix multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`mat @ vec` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> M = torch.randn(2)
|
|||
|
|
>>> mat = torch.randn(2, 3)
|
|||
|
|
>>> vec = torch.randn(3)
|
|||
|
|
>>> torch.addmv(M, mat, vec)
|
|||
|
|
tensor([-0.3768, -5.5565])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addmv(beta: Union[Number, _complex], self: Tensor, mat: Tensor, vec: Tensor, *, out: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addmv(input, mat, vec, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a matrix-vector product of the matrix :attr:`mat` and
|
|||
|
|
the vector :attr:`vec`.
|
|||
|
|
The vector :attr:`input` is added to the final result.
|
|||
|
|
|
|||
|
|
If :attr:`mat` is a :math:`(n \times m)` tensor, :attr:`vec` is a 1-D tensor of
|
|||
|
|
size `m`, then :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a 1-D tensor of size `n` and
|
|||
|
|
:attr:`out` will be 1-D tensor of size `n`.
|
|||
|
|
|
|||
|
|
:attr:`alpha` and :attr:`beta` are scaling factors on matrix-vector product between
|
|||
|
|
:attr:`mat` and :attr:`vec` and the added tensor :attr:`input` respectively.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out} = \beta\ \text{input} + \alpha\ (\text{mat} \mathbin{@} \text{vec})
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, arguments :attr:`beta` and
|
|||
|
|
:attr:`alpha` must be real numbers, otherwise they should be integers.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): vector to be added
|
|||
|
|
mat (Tensor): matrix to be matrix multiplied
|
|||
|
|
vec (Tensor): vector to be matrix multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`mat @ vec` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> M = torch.randn(2)
|
|||
|
|
>>> mat = torch.randn(2, 3)
|
|||
|
|
>>> vec = torch.randn(3)
|
|||
|
|
>>> torch.addmv(M, mat, vec)
|
|||
|
|
tensor([-0.3768, -5.5565])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addmv_(beta: Union[Number, _complex], self: Tensor, alpha: Union[Number, _complex], mat: Tensor, vec: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def addmv_(input: Tensor, mat: Tensor, vec: Tensor, *, beta: Union[Number, _complex] = 1, alpha: Union[Number, _complex] = 1) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def addmv_(beta: Union[Number, _complex], self: Tensor, mat: Tensor, vec: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def addr(beta: Union[Number, _complex], self: Tensor, alpha: Union[Number, _complex], vec1: Tensor, vec2: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addr(input, vec1, vec2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs the outer-product of vectors :attr:`vec1` and :attr:`vec2`
|
|||
|
|
and adds it to the matrix :attr:`input`.
|
|||
|
|
|
|||
|
|
Optional values :attr:`beta` and :attr:`alpha` are scaling factors on the
|
|||
|
|
outer product between :attr:`vec1` and :attr:`vec2` and the added matrix
|
|||
|
|
:attr:`input` respectively.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out} = \beta\ \text{input} + \alpha\ (\text{vec1} \otimes \text{vec2})
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
If :attr:`vec1` is a vector of size `n` and :attr:`vec2` is a vector
|
|||
|
|
of size `m`, then :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a matrix of size
|
|||
|
|
:math:`(n \times m)` and :attr:`out` will be a matrix of size
|
|||
|
|
:math:`(n \times m)`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): matrix to be added
|
|||
|
|
vec1 (Tensor): the first vector of the outer product
|
|||
|
|
vec2 (Tensor): the second vector of the outer product
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`\text{vec1} \otimes \text{vec2}` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> vec1 = torch.arange(1., 4.)
|
|||
|
|
>>> vec2 = torch.arange(1., 3.)
|
|||
|
|
>>> M = torch.zeros(3, 2)
|
|||
|
|
>>> torch.addr(M, vec1, vec2)
|
|||
|
|
tensor([[ 1., 2.],
|
|||
|
|
[ 2., 4.],
|
|||
|
|
[ 3., 6.]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addr(beta: Union[Number, _complex], self: Tensor, alpha: Union[Number, _complex], vec1: Tensor, vec2: Tensor, *, out: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addr(input, vec1, vec2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs the outer-product of vectors :attr:`vec1` and :attr:`vec2`
|
|||
|
|
and adds it to the matrix :attr:`input`.
|
|||
|
|
|
|||
|
|
Optional values :attr:`beta` and :attr:`alpha` are scaling factors on the
|
|||
|
|
outer product between :attr:`vec1` and :attr:`vec2` and the added matrix
|
|||
|
|
:attr:`input` respectively.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out} = \beta\ \text{input} + \alpha\ (\text{vec1} \otimes \text{vec2})
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
If :attr:`vec1` is a vector of size `n` and :attr:`vec2` is a vector
|
|||
|
|
of size `m`, then :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a matrix of size
|
|||
|
|
:math:`(n \times m)` and :attr:`out` will be a matrix of size
|
|||
|
|
:math:`(n \times m)`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): matrix to be added
|
|||
|
|
vec1 (Tensor): the first vector of the outer product
|
|||
|
|
vec2 (Tensor): the second vector of the outer product
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`\text{vec1} \otimes \text{vec2}` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> vec1 = torch.arange(1., 4.)
|
|||
|
|
>>> vec2 = torch.arange(1., 3.)
|
|||
|
|
>>> M = torch.zeros(3, 2)
|
|||
|
|
>>> torch.addr(M, vec1, vec2)
|
|||
|
|
tensor([[ 1., 2.],
|
|||
|
|
[ 2., 4.],
|
|||
|
|
[ 3., 6.]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addr(input: Tensor, vec1: Tensor, vec2: Tensor, *, beta: Union[Number, _complex] = 1, alpha: Union[Number, _complex] = 1, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addr(input, vec1, vec2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs the outer-product of vectors :attr:`vec1` and :attr:`vec2`
|
|||
|
|
and adds it to the matrix :attr:`input`.
|
|||
|
|
|
|||
|
|
Optional values :attr:`beta` and :attr:`alpha` are scaling factors on the
|
|||
|
|
outer product between :attr:`vec1` and :attr:`vec2` and the added matrix
|
|||
|
|
:attr:`input` respectively.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out} = \beta\ \text{input} + \alpha\ (\text{vec1} \otimes \text{vec2})
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
If :attr:`vec1` is a vector of size `n` and :attr:`vec2` is a vector
|
|||
|
|
of size `m`, then :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a matrix of size
|
|||
|
|
:math:`(n \times m)` and :attr:`out` will be a matrix of size
|
|||
|
|
:math:`(n \times m)`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): matrix to be added
|
|||
|
|
vec1 (Tensor): the first vector of the outer product
|
|||
|
|
vec2 (Tensor): the second vector of the outer product
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`\text{vec1} \otimes \text{vec2}` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> vec1 = torch.arange(1., 4.)
|
|||
|
|
>>> vec2 = torch.arange(1., 3.)
|
|||
|
|
>>> M = torch.zeros(3, 2)
|
|||
|
|
>>> torch.addr(M, vec1, vec2)
|
|||
|
|
tensor([[ 1., 2.],
|
|||
|
|
[ 2., 4.],
|
|||
|
|
[ 3., 6.]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addr(beta: Union[Number, _complex], self: Tensor, vec1: Tensor, vec2: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addr(input, vec1, vec2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs the outer-product of vectors :attr:`vec1` and :attr:`vec2`
|
|||
|
|
and adds it to the matrix :attr:`input`.
|
|||
|
|
|
|||
|
|
Optional values :attr:`beta` and :attr:`alpha` are scaling factors on the
|
|||
|
|
outer product between :attr:`vec1` and :attr:`vec2` and the added matrix
|
|||
|
|
:attr:`input` respectively.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out} = \beta\ \text{input} + \alpha\ (\text{vec1} \otimes \text{vec2})
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
If :attr:`vec1` is a vector of size `n` and :attr:`vec2` is a vector
|
|||
|
|
of size `m`, then :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a matrix of size
|
|||
|
|
:math:`(n \times m)` and :attr:`out` will be a matrix of size
|
|||
|
|
:math:`(n \times m)`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): matrix to be added
|
|||
|
|
vec1 (Tensor): the first vector of the outer product
|
|||
|
|
vec2 (Tensor): the second vector of the outer product
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`\text{vec1} \otimes \text{vec2}` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> vec1 = torch.arange(1., 4.)
|
|||
|
|
>>> vec2 = torch.arange(1., 3.)
|
|||
|
|
>>> M = torch.zeros(3, 2)
|
|||
|
|
>>> torch.addr(M, vec1, vec2)
|
|||
|
|
tensor([[ 1., 2.],
|
|||
|
|
[ 2., 4.],
|
|||
|
|
[ 3., 6.]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def addr(beta: Union[Number, _complex], self: Tensor, vec1: Tensor, vec2: Tensor, *, out: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
addr(input, vec1, vec2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs the outer-product of vectors :attr:`vec1` and :attr:`vec2`
|
|||
|
|
and adds it to the matrix :attr:`input`.
|
|||
|
|
|
|||
|
|
Optional values :attr:`beta` and :attr:`alpha` are scaling factors on the
|
|||
|
|
outer product between :attr:`vec1` and :attr:`vec2` and the added matrix
|
|||
|
|
:attr:`input` respectively.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out} = \beta\ \text{input} + \alpha\ (\text{vec1} \otimes \text{vec2})
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
If :attr:`vec1` is a vector of size `n` and :attr:`vec2` is a vector
|
|||
|
|
of size `m`, then :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a matrix of size
|
|||
|
|
:math:`(n \times m)` and :attr:`out` will be a matrix of size
|
|||
|
|
:math:`(n \times m)`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): matrix to be added
|
|||
|
|
vec1 (Tensor): the first vector of the outer product
|
|||
|
|
vec2 (Tensor): the second vector of the outer product
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`\text{vec1} \otimes \text{vec2}` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> vec1 = torch.arange(1., 4.)
|
|||
|
|
>>> vec2 = torch.arange(1., 3.)
|
|||
|
|
>>> M = torch.zeros(3, 2)
|
|||
|
|
>>> torch.addr(M, vec1, vec2)
|
|||
|
|
tensor([[ 1., 2.],
|
|||
|
|
[ 2., 4.],
|
|||
|
|
[ 3., 6.]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def adjoint(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
adjoint(Tensor) -> Tensor
|
|||
|
|
Returns a view of the tensor conjugated and with the last two dimensions transposed.
|
|||
|
|
|
|||
|
|
``x.adjoint()`` is equivalent to ``x.transpose(-2, -1).conj()`` for complex tensors and
|
|||
|
|
to ``x.transpose(-2, -1)`` for real tensors.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
>>> x = torch.arange(4, dtype=torch.float)
|
|||
|
|
>>> A = torch.complex(x, x).reshape(2, 2)
|
|||
|
|
>>> A
|
|||
|
|
tensor([[0.+0.j, 1.+1.j],
|
|||
|
|
[2.+2.j, 3.+3.j]])
|
|||
|
|
>>> A.adjoint()
|
|||
|
|
tensor([[0.-0.j, 2.-2.j],
|
|||
|
|
[1.-1.j, 3.-3.j]])
|
|||
|
|
>>> (A.adjoint() == A.mH).all()
|
|||
|
|
tensor(True)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def affine_grid_generator(theta: Tensor, size: Sequence[Union[_int, SymInt]], align_corners: _bool) -> Tensor: ...
|
|||
|
|
def alias_copy(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.alias`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def all(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
all(input) -> Tensor
|
|||
|
|
|
|||
|
|
Tests if all elements in :attr:`input` evaluate to `True`.
|
|||
|
|
|
|||
|
|
.. note:: This function matches the behaviour of NumPy in returning
|
|||
|
|
output of dtype `bool` for all supported dtypes except `uint8`.
|
|||
|
|
For `uint8` the dtype of output is `uint8` itself.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.rand(1, 2).bool()
|
|||
|
|
>>> a
|
|||
|
|
tensor([[False, True]], dtype=torch.bool)
|
|||
|
|
>>> torch.all(a)
|
|||
|
|
tensor(False, dtype=torch.bool)
|
|||
|
|
>>> a = torch.arange(0, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([0, 1, 2])
|
|||
|
|
>>> torch.all(a)
|
|||
|
|
tensor(False)
|
|||
|
|
|
|||
|
|
.. function:: all(input, dim, keepdim=False, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
For each row of :attr:`input` in the given dimension :attr:`dim`,
|
|||
|
|
returns `True` if all elements in the row evaluate to `True` and `False` otherwise.
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints): the dimension or dimensions to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.rand(4, 2).bool()
|
|||
|
|
>>> a
|
|||
|
|
tensor([[True, True],
|
|||
|
|
[True, False],
|
|||
|
|
[True, True],
|
|||
|
|
[True, True]], dtype=torch.bool)
|
|||
|
|
>>> torch.all(a, dim=1)
|
|||
|
|
tensor([ True, False, True, True], dtype=torch.bool)
|
|||
|
|
>>> torch.all(a, dim=0)
|
|||
|
|
tensor([ True, False], dtype=torch.bool)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def all(input: Tensor, dim: Optional[_size] = None, keepdim: _bool = False, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
all(input) -> Tensor
|
|||
|
|
|
|||
|
|
Tests if all elements in :attr:`input` evaluate to `True`.
|
|||
|
|
|
|||
|
|
.. note:: This function matches the behaviour of NumPy in returning
|
|||
|
|
output of dtype `bool` for all supported dtypes except `uint8`.
|
|||
|
|
For `uint8` the dtype of output is `uint8` itself.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.rand(1, 2).bool()
|
|||
|
|
>>> a
|
|||
|
|
tensor([[False, True]], dtype=torch.bool)
|
|||
|
|
>>> torch.all(a)
|
|||
|
|
tensor(False, dtype=torch.bool)
|
|||
|
|
>>> a = torch.arange(0, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([0, 1, 2])
|
|||
|
|
>>> torch.all(a)
|
|||
|
|
tensor(False)
|
|||
|
|
|
|||
|
|
.. function:: all(input, dim, keepdim=False, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
For each row of :attr:`input` in the given dimension :attr:`dim`,
|
|||
|
|
returns `True` if all elements in the row evaluate to `True` and `False` otherwise.
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints): the dimension or dimensions to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.rand(4, 2).bool()
|
|||
|
|
>>> a
|
|||
|
|
tensor([[True, True],
|
|||
|
|
[True, False],
|
|||
|
|
[True, True],
|
|||
|
|
[True, True]], dtype=torch.bool)
|
|||
|
|
>>> torch.all(a, dim=1)
|
|||
|
|
tensor([ True, False, True, True], dtype=torch.bool)
|
|||
|
|
>>> torch.all(a, dim=0)
|
|||
|
|
tensor([ True, False], dtype=torch.bool)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def all(input: Tensor, dim: _int, keepdim: _bool = False, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
all(input) -> Tensor
|
|||
|
|
|
|||
|
|
Tests if all elements in :attr:`input` evaluate to `True`.
|
|||
|
|
|
|||
|
|
.. note:: This function matches the behaviour of NumPy in returning
|
|||
|
|
output of dtype `bool` for all supported dtypes except `uint8`.
|
|||
|
|
For `uint8` the dtype of output is `uint8` itself.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.rand(1, 2).bool()
|
|||
|
|
>>> a
|
|||
|
|
tensor([[False, True]], dtype=torch.bool)
|
|||
|
|
>>> torch.all(a)
|
|||
|
|
tensor(False, dtype=torch.bool)
|
|||
|
|
>>> a = torch.arange(0, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([0, 1, 2])
|
|||
|
|
>>> torch.all(a)
|
|||
|
|
tensor(False)
|
|||
|
|
|
|||
|
|
.. function:: all(input, dim, keepdim=False, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
For each row of :attr:`input` in the given dimension :attr:`dim`,
|
|||
|
|
returns `True` if all elements in the row evaluate to `True` and `False` otherwise.
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints): the dimension or dimensions to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.rand(4, 2).bool()
|
|||
|
|
>>> a
|
|||
|
|
tensor([[True, True],
|
|||
|
|
[True, False],
|
|||
|
|
[True, True],
|
|||
|
|
[True, True]], dtype=torch.bool)
|
|||
|
|
>>> torch.all(a, dim=1)
|
|||
|
|
tensor([ True, False, True, True], dtype=torch.bool)
|
|||
|
|
>>> torch.all(a, dim=0)
|
|||
|
|
tensor([ True, False], dtype=torch.bool)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def all(input: Tensor, dim: Union[str, ellipsis, None], keepdim: _bool = False, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
all(input) -> Tensor
|
|||
|
|
|
|||
|
|
Tests if all elements in :attr:`input` evaluate to `True`.
|
|||
|
|
|
|||
|
|
.. note:: This function matches the behaviour of NumPy in returning
|
|||
|
|
output of dtype `bool` for all supported dtypes except `uint8`.
|
|||
|
|
For `uint8` the dtype of output is `uint8` itself.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.rand(1, 2).bool()
|
|||
|
|
>>> a
|
|||
|
|
tensor([[False, True]], dtype=torch.bool)
|
|||
|
|
>>> torch.all(a)
|
|||
|
|
tensor(False, dtype=torch.bool)
|
|||
|
|
>>> a = torch.arange(0, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([0, 1, 2])
|
|||
|
|
>>> torch.all(a)
|
|||
|
|
tensor(False)
|
|||
|
|
|
|||
|
|
.. function:: all(input, dim, keepdim=False, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
For each row of :attr:`input` in the given dimension :attr:`dim`,
|
|||
|
|
returns `True` if all elements in the row evaluate to `True` and `False` otherwise.
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints): the dimension or dimensions to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.rand(4, 2).bool()
|
|||
|
|
>>> a
|
|||
|
|
tensor([[True, True],
|
|||
|
|
[True, False],
|
|||
|
|
[True, True],
|
|||
|
|
[True, True]], dtype=torch.bool)
|
|||
|
|
>>> torch.all(a, dim=1)
|
|||
|
|
tensor([ True, False, True, True], dtype=torch.bool)
|
|||
|
|
>>> torch.all(a, dim=0)
|
|||
|
|
tensor([ True, False], dtype=torch.bool)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def allclose(input: Tensor, other: Tensor, rtol: _float = 1e-05, atol: _float = 1e-08, equal_nan: _bool = False) -> _bool:
|
|||
|
|
r"""
|
|||
|
|
allclose(input, other, rtol=1e-05, atol=1e-08, equal_nan=False) -> bool
|
|||
|
|
|
|||
|
|
This function checks if :attr:`input` and :attr:`other` satisfy the condition:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\lvert \text{input} - \text{other} \rvert \leq \texttt{atol} + \texttt{rtol} \times \lvert \text{other} \rvert
|
|||
|
|
|
|||
|
|
elementwise, for all elements of :attr:`input` and :attr:`other`. The behaviour of this function is analogous to
|
|||
|
|
`numpy.allclose <https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html>`_
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): first tensor to compare
|
|||
|
|
other (Tensor): second tensor to compare
|
|||
|
|
atol (float, optional): absolute tolerance. Default: 1e-08
|
|||
|
|
rtol (float, optional): relative tolerance. Default: 1e-05
|
|||
|
|
equal_nan (bool, optional): if ``True``, then two ``NaN`` s will be considered equal. Default: ``False``
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.allclose(torch.tensor([10000., 1e-07]), torch.tensor([10000.1, 1e-08]))
|
|||
|
|
False
|
|||
|
|
>>> torch.allclose(torch.tensor([10000., 1e-08]), torch.tensor([10000.1, 1e-09]))
|
|||
|
|
True
|
|||
|
|
>>> torch.allclose(torch.tensor([1.0, float('nan')]), torch.tensor([1.0, float('nan')]))
|
|||
|
|
False
|
|||
|
|
>>> torch.allclose(torch.tensor([1.0, float('nan')]), torch.tensor([1.0, float('nan')]), equal_nan=True)
|
|||
|
|
True
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def alpha_dropout(input: Tensor, p: _float, train: _bool) -> Tensor: ...
|
|||
|
|
def alpha_dropout_(input: Tensor, p: _float, train: _bool) -> Tensor: ...
|
|||
|
|
def amax(input: Tensor, dim: Union[_int, _size] = (), keepdim: _bool = False, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
amax(input, dim, keepdim=False, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the maximum value of each slice of the :attr:`input` tensor in the given
|
|||
|
|
dimension(s) :attr:`dim`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
The difference between ``max``/``min`` and ``amax``/``amin`` is:
|
|||
|
|
- ``amax``/``amin`` supports reducing on multiple dimensions,
|
|||
|
|
- ``amax``/``amin`` does not return indices,
|
|||
|
|
- ``amax``/``amin`` evenly distributes gradient between equal values,
|
|||
|
|
while ``max(dim)``/``min(dim)`` propagates gradient only to a single
|
|||
|
|
index in the source tensor.
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints): the dimension or dimensions to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.8177, 1.4878, -0.2491, 0.9130],
|
|||
|
|
[-0.7158, 1.1775, 2.0992, 0.4817],
|
|||
|
|
[-0.0053, 0.0164, -1.3738, -0.0507],
|
|||
|
|
[ 1.9700, 1.1106, -1.0318, -1.0816]])
|
|||
|
|
>>> torch.amax(a, 1)
|
|||
|
|
tensor([1.4878, 2.0992, 0.0164, 1.9700])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def amin(input: Tensor, dim: Union[_int, _size] = (), keepdim: _bool = False, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
amin(input, dim, keepdim=False, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the minimum value of each slice of the :attr:`input` tensor in the given
|
|||
|
|
dimension(s) :attr:`dim`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
The difference between ``max``/``min`` and ``amax``/``amin`` is:
|
|||
|
|
- ``amax``/``amin`` supports reducing on multiple dimensions,
|
|||
|
|
- ``amax``/``amin`` does not return indices,
|
|||
|
|
- ``amax``/``amin`` evenly distributes gradient between equal values,
|
|||
|
|
while ``max(dim)``/``min(dim)`` propagates gradient only to a single
|
|||
|
|
index in the source tensor.
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints): the dimension or dimensions to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.6451, -0.4866, 0.2987, -1.3312],
|
|||
|
|
[-0.5744, 1.2980, 1.8397, -0.2713],
|
|||
|
|
[ 0.9128, 0.9214, -1.7268, -0.2995],
|
|||
|
|
[ 0.9023, 0.4853, 0.9075, -1.6165]])
|
|||
|
|
>>> torch.amin(a, 1)
|
|||
|
|
tensor([-1.3312, -0.5744, -1.7268, -1.6165])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def aminmax(input: Tensor, *, dim: Optional[_int] = None, keepdim: _bool = False, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.aminmax:
|
|||
|
|
r"""
|
|||
|
|
aminmax(input, *, dim=None, keepdim=False, out=None) -> (Tensor min, Tensor max)
|
|||
|
|
|
|||
|
|
Computes the minimum and maximum values of the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor):
|
|||
|
|
The input tensor
|
|||
|
|
|
|||
|
|
Keyword Args:
|
|||
|
|
dim (Optional[int]):
|
|||
|
|
The dimension along which to compute the values. If `None`,
|
|||
|
|
computes the values over the entire :attr:`input` tensor.
|
|||
|
|
Default is `None`.
|
|||
|
|
keepdim (bool):
|
|||
|
|
If `True`, the reduced dimensions will be kept in the output
|
|||
|
|
tensor as dimensions with size 1 for broadcasting, otherwise
|
|||
|
|
they will be removed, as if calling (:func:`torch.squeeze`).
|
|||
|
|
Default is `False`.
|
|||
|
|
out (Optional[Tuple[Tensor, Tensor]]):
|
|||
|
|
Optional tensors on which to write the result. Must have the same
|
|||
|
|
shape and dtype as the expected output.
|
|||
|
|
Default is `None`.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A named tuple `(min, max)` containing the minimum and maximum values.
|
|||
|
|
|
|||
|
|
Raises:
|
|||
|
|
RuntimeError
|
|||
|
|
If any of the dimensions to compute the values over has size 0.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
NaN values are propagated to the output if at least one value is NaN.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
:func:`torch.amin` computes just the minimum value
|
|||
|
|
:func:`torch.amax` computes just the maximum value
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.aminmax(torch.tensor([1, -3, 5]))
|
|||
|
|
torch.return_types.aminmax(
|
|||
|
|
min=tensor(-3),
|
|||
|
|
max=tensor(5))
|
|||
|
|
|
|||
|
|
>>> # aminmax propagates NaNs
|
|||
|
|
>>> torch.aminmax(torch.tensor([1, -3, 5, torch.nan]))
|
|||
|
|
torch.return_types.aminmax(
|
|||
|
|
min=tensor(nan),
|
|||
|
|
max=tensor(nan))
|
|||
|
|
|
|||
|
|
>>> t = torch.arange(10).view(2, 5)
|
|||
|
|
>>> t
|
|||
|
|
tensor([[0, 1, 2, 3, 4],
|
|||
|
|
[5, 6, 7, 8, 9]])
|
|||
|
|
>>> t.aminmax(dim=0, keepdim=True)
|
|||
|
|
torch.return_types.aminmax(
|
|||
|
|
min=tensor([[0, 1, 2, 3, 4]]),
|
|||
|
|
max=tensor([[5, 6, 7, 8, 9]]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def angle(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
angle(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the element-wise angle (in radians) of the given :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = angle(\text{input}_{i})
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
.. note:: Starting in PyTorch 1.8, angle returns pi for negative real numbers,
|
|||
|
|
zero for non-negative real numbers, and propagates NaNs. Previously
|
|||
|
|
the function would return zero for all real numbers and not propagate
|
|||
|
|
floating-point NaNs.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.angle(torch.tensor([-1 + 1j, -2 + 2j, 3 - 3j]))*180/3.14159
|
|||
|
|
tensor([ 135., 135, -45])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def any(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
any(input) -> Tensor
|
|||
|
|
|
|||
|
|
Tests if any element in :attr:`input` evaluates to `True`.
|
|||
|
|
|
|||
|
|
.. note:: This function matches the behaviour of NumPy in returning
|
|||
|
|
output of dtype `bool` for all supported dtypes except `uint8`.
|
|||
|
|
For `uint8` the dtype of output is `uint8` itself.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.rand(1, 2).bool()
|
|||
|
|
>>> a
|
|||
|
|
tensor([[False, True]], dtype=torch.bool)
|
|||
|
|
>>> torch.any(a)
|
|||
|
|
tensor(True, dtype=torch.bool)
|
|||
|
|
>>> a = torch.arange(0, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([0, 1, 2])
|
|||
|
|
>>> torch.any(a)
|
|||
|
|
tensor(True)
|
|||
|
|
|
|||
|
|
.. function:: any(input, dim, keepdim=False, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
For each row of :attr:`input` in the given dimension :attr:`dim`,
|
|||
|
|
returns `True` if any element in the row evaluate to `True` and `False` otherwise.
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints): the dimension or dimensions to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 2) < 0
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ True, True],
|
|||
|
|
[False, True],
|
|||
|
|
[ True, True],
|
|||
|
|
[False, False]])
|
|||
|
|
>>> torch.any(a, 1)
|
|||
|
|
tensor([ True, True, True, False])
|
|||
|
|
>>> torch.any(a, 0)
|
|||
|
|
tensor([True, True])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def any(input: Tensor, dim: Optional[_size] = None, keepdim: _bool = False, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
any(input) -> Tensor
|
|||
|
|
|
|||
|
|
Tests if any element in :attr:`input` evaluates to `True`.
|
|||
|
|
|
|||
|
|
.. note:: This function matches the behaviour of NumPy in returning
|
|||
|
|
output of dtype `bool` for all supported dtypes except `uint8`.
|
|||
|
|
For `uint8` the dtype of output is `uint8` itself.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.rand(1, 2).bool()
|
|||
|
|
>>> a
|
|||
|
|
tensor([[False, True]], dtype=torch.bool)
|
|||
|
|
>>> torch.any(a)
|
|||
|
|
tensor(True, dtype=torch.bool)
|
|||
|
|
>>> a = torch.arange(0, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([0, 1, 2])
|
|||
|
|
>>> torch.any(a)
|
|||
|
|
tensor(True)
|
|||
|
|
|
|||
|
|
.. function:: any(input, dim, keepdim=False, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
For each row of :attr:`input` in the given dimension :attr:`dim`,
|
|||
|
|
returns `True` if any element in the row evaluate to `True` and `False` otherwise.
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints): the dimension or dimensions to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 2) < 0
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ True, True],
|
|||
|
|
[False, True],
|
|||
|
|
[ True, True],
|
|||
|
|
[False, False]])
|
|||
|
|
>>> torch.any(a, 1)
|
|||
|
|
tensor([ True, True, True, False])
|
|||
|
|
>>> torch.any(a, 0)
|
|||
|
|
tensor([True, True])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def any(input: Tensor, dim: _int, keepdim: _bool = False, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
any(input) -> Tensor
|
|||
|
|
|
|||
|
|
Tests if any element in :attr:`input` evaluates to `True`.
|
|||
|
|
|
|||
|
|
.. note:: This function matches the behaviour of NumPy in returning
|
|||
|
|
output of dtype `bool` for all supported dtypes except `uint8`.
|
|||
|
|
For `uint8` the dtype of output is `uint8` itself.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.rand(1, 2).bool()
|
|||
|
|
>>> a
|
|||
|
|
tensor([[False, True]], dtype=torch.bool)
|
|||
|
|
>>> torch.any(a)
|
|||
|
|
tensor(True, dtype=torch.bool)
|
|||
|
|
>>> a = torch.arange(0, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([0, 1, 2])
|
|||
|
|
>>> torch.any(a)
|
|||
|
|
tensor(True)
|
|||
|
|
|
|||
|
|
.. function:: any(input, dim, keepdim=False, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
For each row of :attr:`input` in the given dimension :attr:`dim`,
|
|||
|
|
returns `True` if any element in the row evaluate to `True` and `False` otherwise.
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints): the dimension or dimensions to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 2) < 0
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ True, True],
|
|||
|
|
[False, True],
|
|||
|
|
[ True, True],
|
|||
|
|
[False, False]])
|
|||
|
|
>>> torch.any(a, 1)
|
|||
|
|
tensor([ True, True, True, False])
|
|||
|
|
>>> torch.any(a, 0)
|
|||
|
|
tensor([True, True])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def any(input: Tensor, dim: Union[str, ellipsis, None], keepdim: _bool = False, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
any(input) -> Tensor
|
|||
|
|
|
|||
|
|
Tests if any element in :attr:`input` evaluates to `True`.
|
|||
|
|
|
|||
|
|
.. note:: This function matches the behaviour of NumPy in returning
|
|||
|
|
output of dtype `bool` for all supported dtypes except `uint8`.
|
|||
|
|
For `uint8` the dtype of output is `uint8` itself.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.rand(1, 2).bool()
|
|||
|
|
>>> a
|
|||
|
|
tensor([[False, True]], dtype=torch.bool)
|
|||
|
|
>>> torch.any(a)
|
|||
|
|
tensor(True, dtype=torch.bool)
|
|||
|
|
>>> a = torch.arange(0, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([0, 1, 2])
|
|||
|
|
>>> torch.any(a)
|
|||
|
|
tensor(True)
|
|||
|
|
|
|||
|
|
.. function:: any(input, dim, keepdim=False, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
For each row of :attr:`input` in the given dimension :attr:`dim`,
|
|||
|
|
returns `True` if any element in the row evaluate to `True` and `False` otherwise.
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints): the dimension or dimensions to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 2) < 0
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ True, True],
|
|||
|
|
[False, True],
|
|||
|
|
[ True, True],
|
|||
|
|
[False, False]])
|
|||
|
|
>>> torch.any(a, 1)
|
|||
|
|
tensor([ True, True, True, False])
|
|||
|
|
>>> torch.any(a, 0)
|
|||
|
|
tensor([True, True])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def arange(start: Number, end: Number, step: Number, *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, device: Optional[DeviceLikeType] = None, requires_grad: _bool = False, pin_memory: _bool = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
arange(start=0, end, step=1, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a 1-D tensor of size :math:`\left\lceil \frac{\text{end} - \text{start}}{\text{step}} \right\rceil`
|
|||
|
|
with values from the interval ``[start, end)`` taken with common difference
|
|||
|
|
:attr:`step` beginning from `start`.
|
|||
|
|
|
|||
|
|
Note that non-integer :attr:`step` is subject to floating point rounding errors when
|
|||
|
|
comparing against :attr:`end`; to avoid inconsistency, we advise subtracting a small epsilon from :attr:`end`
|
|||
|
|
in such cases.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{{i+1}} = \text{out}_{i} + \text{step}
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
start (Number): the starting value for the set of points. Default: ``0``.
|
|||
|
|
end (Number): the ending value for the set of points
|
|||
|
|
step (Number): the gap between each pair of adjacent points. Default: ``1``.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`). If `dtype` is not given, infer the data type from the other input
|
|||
|
|
arguments. If any of `start`, `end`, or `stop` are floating-point, the
|
|||
|
|
`dtype` is inferred to be the default dtype, see
|
|||
|
|
:meth:`~torch.get_default_dtype`. Otherwise, the `dtype` is inferred to
|
|||
|
|
be `torch.int64`.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.arange(5)
|
|||
|
|
tensor([ 0, 1, 2, 3, 4])
|
|||
|
|
>>> torch.arange(1, 4)
|
|||
|
|
tensor([ 1, 2, 3])
|
|||
|
|
>>> torch.arange(1, 2.5, 0.5)
|
|||
|
|
tensor([ 1.0000, 1.5000, 2.0000])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def arange(start: Number, end: Number, *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, device: Optional[DeviceLikeType] = None, requires_grad: _bool = False, pin_memory: _bool = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
arange(start=0, end, step=1, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a 1-D tensor of size :math:`\left\lceil \frac{\text{end} - \text{start}}{\text{step}} \right\rceil`
|
|||
|
|
with values from the interval ``[start, end)`` taken with common difference
|
|||
|
|
:attr:`step` beginning from `start`.
|
|||
|
|
|
|||
|
|
Note that non-integer :attr:`step` is subject to floating point rounding errors when
|
|||
|
|
comparing against :attr:`end`; to avoid inconsistency, we advise subtracting a small epsilon from :attr:`end`
|
|||
|
|
in such cases.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{{i+1}} = \text{out}_{i} + \text{step}
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
start (Number): the starting value for the set of points. Default: ``0``.
|
|||
|
|
end (Number): the ending value for the set of points
|
|||
|
|
step (Number): the gap between each pair of adjacent points. Default: ``1``.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`). If `dtype` is not given, infer the data type from the other input
|
|||
|
|
arguments. If any of `start`, `end`, or `stop` are floating-point, the
|
|||
|
|
`dtype` is inferred to be the default dtype, see
|
|||
|
|
:meth:`~torch.get_default_dtype`. Otherwise, the `dtype` is inferred to
|
|||
|
|
be `torch.int64`.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.arange(5)
|
|||
|
|
tensor([ 0, 1, 2, 3, 4])
|
|||
|
|
>>> torch.arange(1, 4)
|
|||
|
|
tensor([ 1, 2, 3])
|
|||
|
|
>>> torch.arange(1, 2.5, 0.5)
|
|||
|
|
tensor([ 1.0000, 1.5000, 2.0000])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def arange(end: Number, *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, device: Optional[DeviceLikeType] = None, requires_grad: _bool = False, pin_memory: _bool = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
arange(start=0, end, step=1, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a 1-D tensor of size :math:`\left\lceil \frac{\text{end} - \text{start}}{\text{step}} \right\rceil`
|
|||
|
|
with values from the interval ``[start, end)`` taken with common difference
|
|||
|
|
:attr:`step` beginning from `start`.
|
|||
|
|
|
|||
|
|
Note that non-integer :attr:`step` is subject to floating point rounding errors when
|
|||
|
|
comparing against :attr:`end`; to avoid inconsistency, we advise subtracting a small epsilon from :attr:`end`
|
|||
|
|
in such cases.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{{i+1}} = \text{out}_{i} + \text{step}
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
start (Number): the starting value for the set of points. Default: ``0``.
|
|||
|
|
end (Number): the ending value for the set of points
|
|||
|
|
step (Number): the gap between each pair of adjacent points. Default: ``1``.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`). If `dtype` is not given, infer the data type from the other input
|
|||
|
|
arguments. If any of `start`, `end`, or `stop` are floating-point, the
|
|||
|
|
`dtype` is inferred to be the default dtype, see
|
|||
|
|
:meth:`~torch.get_default_dtype`. Otherwise, the `dtype` is inferred to
|
|||
|
|
be `torch.int64`.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.arange(5)
|
|||
|
|
tensor([ 0, 1, 2, 3, 4])
|
|||
|
|
>>> torch.arange(1, 4)
|
|||
|
|
tensor([ 1, 2, 3])
|
|||
|
|
>>> torch.arange(1, 2.5, 0.5)
|
|||
|
|
tensor([ 1.0000, 1.5000, 2.0000])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def arange(end: Union[Number, _complex], *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
arange(start=0, end, step=1, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a 1-D tensor of size :math:`\left\lceil \frac{\text{end} - \text{start}}{\text{step}} \right\rceil`
|
|||
|
|
with values from the interval ``[start, end)`` taken with common difference
|
|||
|
|
:attr:`step` beginning from `start`.
|
|||
|
|
|
|||
|
|
Note that non-integer :attr:`step` is subject to floating point rounding errors when
|
|||
|
|
comparing against :attr:`end`; to avoid inconsistency, we advise subtracting a small epsilon from :attr:`end`
|
|||
|
|
in such cases.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{{i+1}} = \text{out}_{i} + \text{step}
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
start (Number): the starting value for the set of points. Default: ``0``.
|
|||
|
|
end (Number): the ending value for the set of points
|
|||
|
|
step (Number): the gap between each pair of adjacent points. Default: ``1``.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`). If `dtype` is not given, infer the data type from the other input
|
|||
|
|
arguments. If any of `start`, `end`, or `stop` are floating-point, the
|
|||
|
|
`dtype` is inferred to be the default dtype, see
|
|||
|
|
:meth:`~torch.get_default_dtype`. Otherwise, the `dtype` is inferred to
|
|||
|
|
be `torch.int64`.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.arange(5)
|
|||
|
|
tensor([ 0, 1, 2, 3, 4])
|
|||
|
|
>>> torch.arange(1, 4)
|
|||
|
|
tensor([ 1, 2, 3])
|
|||
|
|
>>> torch.arange(1, 2.5, 0.5)
|
|||
|
|
tensor([ 1.0000, 1.5000, 2.0000])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def arange(start: Union[Number, _complex], end: Union[Number, _complex], *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
arange(start=0, end, step=1, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a 1-D tensor of size :math:`\left\lceil \frac{\text{end} - \text{start}}{\text{step}} \right\rceil`
|
|||
|
|
with values from the interval ``[start, end)`` taken with common difference
|
|||
|
|
:attr:`step` beginning from `start`.
|
|||
|
|
|
|||
|
|
Note that non-integer :attr:`step` is subject to floating point rounding errors when
|
|||
|
|
comparing against :attr:`end`; to avoid inconsistency, we advise subtracting a small epsilon from :attr:`end`
|
|||
|
|
in such cases.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{{i+1}} = \text{out}_{i} + \text{step}
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
start (Number): the starting value for the set of points. Default: ``0``.
|
|||
|
|
end (Number): the ending value for the set of points
|
|||
|
|
step (Number): the gap between each pair of adjacent points. Default: ``1``.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`). If `dtype` is not given, infer the data type from the other input
|
|||
|
|
arguments. If any of `start`, `end`, or `stop` are floating-point, the
|
|||
|
|
`dtype` is inferred to be the default dtype, see
|
|||
|
|
:meth:`~torch.get_default_dtype`. Otherwise, the `dtype` is inferred to
|
|||
|
|
be `torch.int64`.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.arange(5)
|
|||
|
|
tensor([ 0, 1, 2, 3, 4])
|
|||
|
|
>>> torch.arange(1, 4)
|
|||
|
|
tensor([ 1, 2, 3])
|
|||
|
|
>>> torch.arange(1, 2.5, 0.5)
|
|||
|
|
tensor([ 1.0000, 1.5000, 2.0000])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def arange(start: Union[Number, _complex], end: Union[Number, _complex], step: Union[Number, _complex] = 1, *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
arange(start=0, end, step=1, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a 1-D tensor of size :math:`\left\lceil \frac{\text{end} - \text{start}}{\text{step}} \right\rceil`
|
|||
|
|
with values from the interval ``[start, end)`` taken with common difference
|
|||
|
|
:attr:`step` beginning from `start`.
|
|||
|
|
|
|||
|
|
Note that non-integer :attr:`step` is subject to floating point rounding errors when
|
|||
|
|
comparing against :attr:`end`; to avoid inconsistency, we advise subtracting a small epsilon from :attr:`end`
|
|||
|
|
in such cases.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{{i+1}} = \text{out}_{i} + \text{step}
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
start (Number): the starting value for the set of points. Default: ``0``.
|
|||
|
|
end (Number): the ending value for the set of points
|
|||
|
|
step (Number): the gap between each pair of adjacent points. Default: ``1``.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`). If `dtype` is not given, infer the data type from the other input
|
|||
|
|
arguments. If any of `start`, `end`, or `stop` are floating-point, the
|
|||
|
|
`dtype` is inferred to be the default dtype, see
|
|||
|
|
:meth:`~torch.get_default_dtype`. Otherwise, the `dtype` is inferred to
|
|||
|
|
be `torch.int64`.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.arange(5)
|
|||
|
|
tensor([ 0, 1, 2, 3, 4])
|
|||
|
|
>>> torch.arange(1, 4)
|
|||
|
|
tensor([ 1, 2, 3])
|
|||
|
|
>>> torch.arange(1, 2.5, 0.5)
|
|||
|
|
tensor([ 1.0000, 1.5000, 2.0000])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def arccos(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
arccos(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.acos`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def arccos_(input: Tensor) -> Tensor: ...
|
|||
|
|
def arccosh(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
arccosh(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.acosh`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def arccosh_(input: Tensor) -> Tensor: ...
|
|||
|
|
def arcsin(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
arcsin(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.asin`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def arcsin_(input: Tensor) -> Tensor: ...
|
|||
|
|
def arcsinh(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
arcsinh(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.asinh`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def arcsinh_(input: Tensor) -> Tensor: ...
|
|||
|
|
def arctan(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
arctan(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.atan`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def arctan2(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
arctan2(input, other, *, out=None) -> Tensor
|
|||
|
|
Alias for :func:`torch.atan2`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def arctan_(input: Tensor) -> Tensor: ...
|
|||
|
|
def arctanh(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
arctanh(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.atanh`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def arctanh_(input: Tensor) -> Tensor: ...
|
|||
|
|
def argmax(input: Tensor, dim: Optional[_int] = None, keepdim: _bool = False, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
argmax(input) -> LongTensor
|
|||
|
|
|
|||
|
|
Returns the indices of the maximum value of all elements in the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
This is the second value returned by :meth:`torch.max`. See its
|
|||
|
|
documentation for the exact semantics of this method.
|
|||
|
|
|
|||
|
|
.. note:: If there are multiple maximal values then the indices of the first maximal value are returned.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 1.3398, 0.2663, -0.2686, 0.2450],
|
|||
|
|
[-0.7401, -0.8805, -0.3402, -1.1936],
|
|||
|
|
[ 0.4907, -1.3948, -1.0691, -0.3132],
|
|||
|
|
[-1.6092, 0.5419, -0.2993, 0.3195]])
|
|||
|
|
>>> torch.argmax(a)
|
|||
|
|
tensor(0)
|
|||
|
|
|
|||
|
|
.. function:: argmax(input, dim, keepdim=False) -> LongTensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns the indices of the maximum values of a tensor across a dimension.
|
|||
|
|
|
|||
|
|
This is the second value returned by :meth:`torch.max`. See its
|
|||
|
|
documentation for the exact semantics of this method.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to reduce. If ``None``, the argmax of the flattened input is returned.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 1.3398, 0.2663, -0.2686, 0.2450],
|
|||
|
|
[-0.7401, -0.8805, -0.3402, -1.1936],
|
|||
|
|
[ 0.4907, -1.3948, -1.0691, -0.3132],
|
|||
|
|
[-1.6092, 0.5419, -0.2993, 0.3195]])
|
|||
|
|
>>> torch.argmax(a, dim=1)
|
|||
|
|
tensor([ 0, 2, 0, 1])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def argmin(input: Tensor, dim: Optional[_int] = None, keepdim: _bool = False, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
argmin(input, dim=None, keepdim=False) -> LongTensor
|
|||
|
|
|
|||
|
|
Returns the indices of the minimum value(s) of the flattened tensor or along a dimension
|
|||
|
|
|
|||
|
|
This is the second value returned by :meth:`torch.min`. See its
|
|||
|
|
documentation for the exact semantics of this method.
|
|||
|
|
|
|||
|
|
.. note:: If there are multiple minimal values then the indices of the first minimal value are returned.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to reduce. If ``None``, the argmin of the flattened input is returned.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.1139, 0.2254, -0.1381, 0.3687],
|
|||
|
|
[ 1.0100, -1.1975, -0.0102, -0.4732],
|
|||
|
|
[-0.9240, 0.1207, -0.7506, -1.0213],
|
|||
|
|
[ 1.7809, -1.2960, 0.9384, 0.1438]])
|
|||
|
|
>>> torch.argmin(a)
|
|||
|
|
tensor(13)
|
|||
|
|
>>> torch.argmin(a, dim=1)
|
|||
|
|
tensor([ 2, 1, 3, 1])
|
|||
|
|
>>> torch.argmin(a, dim=1, keepdim=True)
|
|||
|
|
tensor([[2],
|
|||
|
|
[1],
|
|||
|
|
[3],
|
|||
|
|
[1]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def argsort(input: Tensor, *, stable: _bool, dim: _int = -1, descending: _bool = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
argsort(input, dim=-1, descending=False, stable=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the indices that sort a tensor along a given dimension in ascending
|
|||
|
|
order by value.
|
|||
|
|
|
|||
|
|
This is the second value returned by :meth:`torch.sort`. See its documentation
|
|||
|
|
for the exact semantics of this method.
|
|||
|
|
|
|||
|
|
If :attr:`stable` is ``True`` then the sorting routine becomes stable, preserving
|
|||
|
|
the order of equivalent elements. If ``False``, the relative order of values
|
|||
|
|
which compare equal is not guaranteed. ``True`` is slower.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int, optional): the dimension to sort along
|
|||
|
|
descending (bool, optional): controls the sorting order (ascending or descending)
|
|||
|
|
stable (bool, optional): controls the relative order of equivalent elements
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.0785, 1.5267, -0.8521, 0.4065],
|
|||
|
|
[ 0.1598, 0.0788, -0.0745, -1.2700],
|
|||
|
|
[ 1.2208, 1.0722, -0.7064, 1.2564],
|
|||
|
|
[ 0.0669, -0.2318, -0.8229, -0.9280]])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> torch.argsort(a, dim=1)
|
|||
|
|
tensor([[2, 0, 3, 1],
|
|||
|
|
[3, 2, 1, 0],
|
|||
|
|
[2, 1, 0, 3],
|
|||
|
|
[3, 2, 1, 0]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def argsort(input: Tensor, dim: _int = -1, descending: _bool = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
argsort(input, dim=-1, descending=False, stable=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the indices that sort a tensor along a given dimension in ascending
|
|||
|
|
order by value.
|
|||
|
|
|
|||
|
|
This is the second value returned by :meth:`torch.sort`. See its documentation
|
|||
|
|
for the exact semantics of this method.
|
|||
|
|
|
|||
|
|
If :attr:`stable` is ``True`` then the sorting routine becomes stable, preserving
|
|||
|
|
the order of equivalent elements. If ``False``, the relative order of values
|
|||
|
|
which compare equal is not guaranteed. ``True`` is slower.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int, optional): the dimension to sort along
|
|||
|
|
descending (bool, optional): controls the sorting order (ascending or descending)
|
|||
|
|
stable (bool, optional): controls the relative order of equivalent elements
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.0785, 1.5267, -0.8521, 0.4065],
|
|||
|
|
[ 0.1598, 0.0788, -0.0745, -1.2700],
|
|||
|
|
[ 1.2208, 1.0722, -0.7064, 1.2564],
|
|||
|
|
[ 0.0669, -0.2318, -0.8229, -0.9280]])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> torch.argsort(a, dim=1)
|
|||
|
|
tensor([[2, 0, 3, 1],
|
|||
|
|
[3, 2, 1, 0],
|
|||
|
|
[2, 1, 0, 3],
|
|||
|
|
[3, 2, 1, 0]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def argsort(input: Tensor, dim: Union[str, ellipsis, None], descending: _bool = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
argsort(input, dim=-1, descending=False, stable=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the indices that sort a tensor along a given dimension in ascending
|
|||
|
|
order by value.
|
|||
|
|
|
|||
|
|
This is the second value returned by :meth:`torch.sort`. See its documentation
|
|||
|
|
for the exact semantics of this method.
|
|||
|
|
|
|||
|
|
If :attr:`stable` is ``True`` then the sorting routine becomes stable, preserving
|
|||
|
|
the order of equivalent elements. If ``False``, the relative order of values
|
|||
|
|
which compare equal is not guaranteed. ``True`` is slower.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int, optional): the dimension to sort along
|
|||
|
|
descending (bool, optional): controls the sorting order (ascending or descending)
|
|||
|
|
stable (bool, optional): controls the relative order of equivalent elements
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.0785, 1.5267, -0.8521, 0.4065],
|
|||
|
|
[ 0.1598, 0.0788, -0.0745, -1.2700],
|
|||
|
|
[ 1.2208, 1.0722, -0.7064, 1.2564],
|
|||
|
|
[ 0.0669, -0.2318, -0.8229, -0.9280]])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> torch.argsort(a, dim=1)
|
|||
|
|
tensor([[2, 0, 3, 1],
|
|||
|
|
[3, 2, 1, 0],
|
|||
|
|
[2, 1, 0, 3],
|
|||
|
|
[3, 2, 1, 0]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def argwhere(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
argwhere(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor containing the indices of all non-zero elements of
|
|||
|
|
:attr:`input`. Each row in the result contains the indices of a non-zero
|
|||
|
|
element in :attr:`input`. The result is sorted lexicographically, with
|
|||
|
|
the last index changing the fastest (C-style).
|
|||
|
|
|
|||
|
|
If :attr:`input` has :math:`n` dimensions, then the resulting indices tensor
|
|||
|
|
:attr:`out` is of size :math:`(z \times n)`, where :math:`z` is the total number of
|
|||
|
|
non-zero elements in the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
This function is similar to NumPy's `argwhere`.
|
|||
|
|
|
|||
|
|
When :attr:`input` is on CUDA, this function causes host-device synchronization.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
{input}
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> t = torch.tensor([1, 0, 1])
|
|||
|
|
>>> torch.argwhere(t)
|
|||
|
|
tensor([[0],
|
|||
|
|
[2]])
|
|||
|
|
>>> t = torch.tensor([[1, 0, 1], [0, 1, 1]])
|
|||
|
|
>>> torch.argwhere(t)
|
|||
|
|
tensor([[0, 0],
|
|||
|
|
[0, 2],
|
|||
|
|
[1, 1],
|
|||
|
|
[1, 2]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def as_strided(input: Tensor, size: Sequence[Union[_int, SymInt]], stride: Sequence[Union[_int, SymInt]], storage_offset: Optional[Union[_int, SymInt]] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
as_strided(input, size, stride, storage_offset=None) -> Tensor
|
|||
|
|
|
|||
|
|
Create a view of an existing `torch.Tensor` :attr:`input` with specified
|
|||
|
|
:attr:`size`, :attr:`stride` and :attr:`storage_offset`.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
Prefer using other view functions, like :meth:`torch.Tensor.expand`,
|
|||
|
|
to setting a view's strides manually with `as_strided`, as this
|
|||
|
|
function's behavior depends on the implementation of a tensor's storage.
|
|||
|
|
The constructed view of the storage must only refer to elements within
|
|||
|
|
the storage or a runtime error will be thrown, and if the view is
|
|||
|
|
"overlapped" (with multiple indices referring to the same element in
|
|||
|
|
memory) its behavior is undefined.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
size (tuple or ints): the shape of the output tensor
|
|||
|
|
stride (tuple or ints): the stride of the output tensor
|
|||
|
|
storage_offset (int, optional): the offset in the underlying storage of the output tensor.
|
|||
|
|
If ``None``, the storage_offset of the output tensor will match the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(3, 3)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 0.9039, 0.6291, 1.0795],
|
|||
|
|
[ 0.1586, 2.1939, -0.4900],
|
|||
|
|
[-0.1909, -0.7503, 1.9355]])
|
|||
|
|
>>> t = torch.as_strided(x, (2, 2), (1, 2))
|
|||
|
|
>>> t
|
|||
|
|
tensor([[0.9039, 1.0795],
|
|||
|
|
[0.6291, 0.1586]])
|
|||
|
|
>>> t = torch.as_strided(x, (2, 2), (1, 2), 1)
|
|||
|
|
tensor([[0.6291, 0.1586],
|
|||
|
|
[1.0795, 2.1939]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def as_strided_(input: Tensor, size: Sequence[Union[_int, SymInt]], stride: Sequence[Union[_int, SymInt]], storage_offset: Optional[Union[_int, SymInt]] = None) -> Tensor: ...
|
|||
|
|
def as_strided_copy(input: Tensor, size: Sequence[Union[_int, SymInt]], stride: Sequence[Union[_int, SymInt]], storage_offset: Optional[Union[_int, SymInt]] = None, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.as_strided`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def as_strided_scatter(input: Tensor, src: Tensor, size: Sequence[Union[_int, SymInt]], stride: Sequence[Union[_int, SymInt]], storage_offset: Optional[Union[_int, SymInt]] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
as_strided_scatter(input, src, size, stride, storage_offset=None) -> Tensor
|
|||
|
|
|
|||
|
|
Embeds the values of the :attr:`src` tensor into :attr:`input` along
|
|||
|
|
the elements corresponding to the result of calling
|
|||
|
|
input.as_strided(size, stride, storage_offset).
|
|||
|
|
|
|||
|
|
This function returns a tensor with fresh storage; it does not
|
|||
|
|
return a view.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
size (tuple or ints): the shape of the output tensor
|
|||
|
|
stride (tuple or ints): the stride of the output tensor
|
|||
|
|
storage_offset (int, optional): the offset in the underlying storage of the output tensor
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
:attr:`src` must be of the proper size in order to be embedded
|
|||
|
|
into :attr:`input`. Specifically, it should have the same shape as
|
|||
|
|
`torch.as_strided(input, size, stride, storage_offset)`
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.arange(4).reshape(2, 2) + 1
|
|||
|
|
>>> a
|
|||
|
|
tensor([[1, 2],
|
|||
|
|
[3, 4]])
|
|||
|
|
>>> b = torch.zeros(3, 3)
|
|||
|
|
>>> b
|
|||
|
|
tensor([[0., 0., 0.],
|
|||
|
|
[0., 0., 0.],
|
|||
|
|
[0., 0., 0.]])
|
|||
|
|
>>> torch.as_strided_scatter(b, a, (2, 2), (1, 2))
|
|||
|
|
tensor([[1., 3., 2.],
|
|||
|
|
[4., 0., 0.],
|
|||
|
|
[0., 0., 0.]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def as_tensor(data: Any, dtype: Optional[_dtype] = None, device: Optional[DeviceLikeType] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
as_tensor(data, dtype=None, device=None) -> Tensor
|
|||
|
|
|
|||
|
|
Converts :attr:`data` into a tensor, sharing data and preserving autograd
|
|||
|
|
history if possible.
|
|||
|
|
|
|||
|
|
If :attr:`data` is already a tensor with the requested dtype and device
|
|||
|
|
then :attr:`data` itself is returned, but if :attr:`data` is a
|
|||
|
|
tensor with a different dtype or device then it's copied as if using
|
|||
|
|
`data.to(dtype=dtype, device=device)`.
|
|||
|
|
|
|||
|
|
If :attr:`data` is a NumPy array (an ndarray) with the same dtype and device then a
|
|||
|
|
tensor is constructed using :func:`torch.from_numpy`.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.tensor` never shares its data and creates a new "leaf tensor" (see :doc:`/notes/autograd`).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
data (array_like): Initial data for the tensor. Can be a list, tuple,
|
|||
|
|
NumPy ``ndarray``, scalar, and other types.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, infers data type from :attr:`data`.
|
|||
|
|
device (:class:`torch.device`, optional): the device of the constructed tensor. If None and data is a tensor
|
|||
|
|
then the device of data is used. If None and data is not a tensor then
|
|||
|
|
the result tensor is constructed on the current device.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = numpy.array([1, 2, 3])
|
|||
|
|
>>> t = torch.as_tensor(a)
|
|||
|
|
>>> t
|
|||
|
|
tensor([ 1, 2, 3])
|
|||
|
|
>>> t[0] = -1
|
|||
|
|
>>> a
|
|||
|
|
array([-1, 2, 3])
|
|||
|
|
|
|||
|
|
>>> a = numpy.array([1, 2, 3])
|
|||
|
|
>>> t = torch.as_tensor(a, device=torch.device('cuda'))
|
|||
|
|
>>> t
|
|||
|
|
tensor([ 1, 2, 3])
|
|||
|
|
>>> t[0] = -1
|
|||
|
|
>>> a
|
|||
|
|
array([1, 2, 3])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def asarray(obj: Any, *, dtype: Optional[_dtype] = None, device: Optional[DeviceLikeType] = None, copy: Optional[_bool] = None, requires_grad: _bool = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
asarray(obj, *, dtype=None, device=None, copy=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Converts :attr:`obj` to a tensor.
|
|||
|
|
|
|||
|
|
:attr:`obj` can be one of:
|
|||
|
|
|
|||
|
|
1. a tensor
|
|||
|
|
2. a NumPy array or a NumPy scalar
|
|||
|
|
3. a DLPack capsule
|
|||
|
|
4. an object that implements Python's buffer protocol
|
|||
|
|
5. a scalar
|
|||
|
|
6. a sequence of scalars
|
|||
|
|
|
|||
|
|
When :attr:`obj` is a tensor, NumPy array, or DLPack capsule the returned tensor will,
|
|||
|
|
by default, not require a gradient, have the same datatype as :attr:`obj`, be on the
|
|||
|
|
same device, and share memory with it. These properties can be controlled with the
|
|||
|
|
:attr:`dtype`, :attr:`device`, :attr:`copy`, and :attr:`requires_grad` keyword arguments.
|
|||
|
|
If the returned tensor is of a different datatype, on a different device, or a copy is
|
|||
|
|
requested then it will not share its memory with :attr:`obj`. If :attr:`requires_grad`
|
|||
|
|
is ``True`` then the returned tensor will require a gradient, and if :attr:`obj` is
|
|||
|
|
also a tensor with an autograd history then the returned tensor will have the same history.
|
|||
|
|
|
|||
|
|
When :attr:`obj` is not a tensor, NumPy array, or DLPack capsule but implements Python's
|
|||
|
|
buffer protocol then the buffer is interpreted as an array of bytes grouped according to
|
|||
|
|
the size of the datatype passed to the :attr:`dtype` keyword argument. (If no datatype is
|
|||
|
|
passed then the default floating point datatype is used, instead.) The returned tensor
|
|||
|
|
will have the specified datatype (or default floating point datatype if none is specified)
|
|||
|
|
and, by default, be on the CPU device and share memory with the buffer.
|
|||
|
|
|
|||
|
|
When :attr:`obj` is a NumPy scalar, the returned tensor will be a 0-dimensional tensor on
|
|||
|
|
the CPU and that doesn't share its memory (i.e. ``copy=True``). By default datatype will
|
|||
|
|
be the PyTorch datatype corresponding to the NumPy's scalar's datatype.
|
|||
|
|
|
|||
|
|
When :attr:`obj` is none of the above but a scalar, or a sequence of scalars then the
|
|||
|
|
returned tensor will, by default, infer its datatype from the scalar values, be on the
|
|||
|
|
current default device, and not share its memory.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.tensor` creates a tensor that always copies the data from the input object.
|
|||
|
|
:func:`torch.from_numpy` creates a tensor that always shares memory from NumPy arrays.
|
|||
|
|
:func:`torch.frombuffer` creates a tensor that always shares memory from objects that
|
|||
|
|
implement the buffer protocol.
|
|||
|
|
:func:`torch.from_dlpack` creates a tensor that always shares memory from
|
|||
|
|
DLPack capsules.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
obj (object): a tensor, NumPy array, DLPack Capsule, object that implements Python's
|
|||
|
|
buffer protocol, scalar, or sequence of scalars.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the datatype of the returned tensor.
|
|||
|
|
Default: ``None``, which causes the datatype of the returned tensor to be
|
|||
|
|
inferred from :attr:`obj`.
|
|||
|
|
copy (bool, optional): controls whether the returned tensor shares memory with :attr:`obj`.
|
|||
|
|
Default: ``None``, which causes the returned tensor to share memory with :attr:`obj`
|
|||
|
|
whenever possible. If ``True`` then the returned tensor does not share its memory.
|
|||
|
|
If ``False`` then the returned tensor shares its memory with :attr:`obj` and an
|
|||
|
|
error is thrown if it cannot.
|
|||
|
|
device (:class:`torch.device`, optional): the device of the returned tensor.
|
|||
|
|
Default: ``None``, which causes the device of :attr:`obj` to be used. Or, if
|
|||
|
|
:attr:`obj` is a Python sequence, the current default device will be used.
|
|||
|
|
requires_grad (bool, optional): whether the returned tensor requires grad.
|
|||
|
|
Default: ``False``, which causes the returned tensor not to require a gradient.
|
|||
|
|
If ``True``, then the returned tensor will require a gradient, and if :attr:`obj`
|
|||
|
|
is also a tensor with an autograd history then the returned tensor will have
|
|||
|
|
the same history.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([1, 2, 3])
|
|||
|
|
>>> # Shares memory with tensor 'a'
|
|||
|
|
>>> b = torch.asarray(a)
|
|||
|
|
>>> a.data_ptr() == b.data_ptr()
|
|||
|
|
True
|
|||
|
|
>>> # Forces memory copy
|
|||
|
|
>>> c = torch.asarray(a, copy=True)
|
|||
|
|
>>> a.data_ptr() == c.data_ptr()
|
|||
|
|
False
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([1., 2., 3.], requires_grad=True)
|
|||
|
|
>>> b = a + 2
|
|||
|
|
>>> b
|
|||
|
|
tensor([3., 4., 5.], grad_fn=<AddBackward0>)
|
|||
|
|
>>> # Shares memory with tensor 'b', with no grad
|
|||
|
|
>>> c = torch.asarray(b)
|
|||
|
|
>>> c
|
|||
|
|
tensor([3., 4., 5.])
|
|||
|
|
>>> # Shares memory with tensor 'b', retaining autograd history
|
|||
|
|
>>> d = torch.asarray(b, requires_grad=True)
|
|||
|
|
>>> d
|
|||
|
|
tensor([3., 4., 5.], grad_fn=<AddBackward0>)
|
|||
|
|
|
|||
|
|
>>> array = numpy.array([1, 2, 3])
|
|||
|
|
>>> # Shares memory with array 'array'
|
|||
|
|
>>> t1 = torch.asarray(array)
|
|||
|
|
>>> array.__array_interface__['data'][0] == t1.data_ptr()
|
|||
|
|
True
|
|||
|
|
>>> # Copies memory due to dtype mismatch
|
|||
|
|
>>> t2 = torch.asarray(array, dtype=torch.float32)
|
|||
|
|
>>> array.__array_interface__['data'][0] == t2.data_ptr()
|
|||
|
|
False
|
|||
|
|
|
|||
|
|
>>> scalar = numpy.float64(0.5)
|
|||
|
|
>>> torch.asarray(scalar)
|
|||
|
|
tensor(0.5000, dtype=torch.float64)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def asin(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
asin(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the arcsine of the elements of :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \sin^{-1}(\text{input}_{i})
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([-0.5962, 1.4985, -0.4396, 1.4525])
|
|||
|
|
>>> torch.asin(a)
|
|||
|
|
tensor([-0.6387, nan, -0.4552, nan])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def asin_(input: Tensor) -> Tensor: ...
|
|||
|
|
def asinh(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
asinh(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the inverse hyperbolic sine of the elements of :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \sinh^{-1}(\text{input}_{i})
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 0.1606, -1.4267, -1.0899, -1.0250 ])
|
|||
|
|
>>> torch.asinh(a)
|
|||
|
|
tensor([ 0.1599, -1.1534, -0.9435, -0.8990 ])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def asinh_(input: Tensor) -> Tensor: ...
|
|||
|
|
def atan(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
atan(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the arctangent of the elements of :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \tan^{-1}(\text{input}_{i})
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 0.2341, 0.2539, -0.6256, -0.6448])
|
|||
|
|
>>> torch.atan(a)
|
|||
|
|
tensor([ 0.2299, 0.2487, -0.5591, -0.5727])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def atan2(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
atan2(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Element-wise arctangent of :math:`\text{input}_{i} / \text{other}_{i}`
|
|||
|
|
with consideration of the quadrant. Returns a new tensor with the signed angles
|
|||
|
|
in radians between vector :math:`(\text{other}_{i}, \text{input}_{i})`
|
|||
|
|
and vector :math:`(1, 0)`. (Note that :math:`\text{other}_{i}`, the second
|
|||
|
|
parameter, is the x-coordinate, while :math:`\text{input}_{i}`, the first
|
|||
|
|
parameter, is the y-coordinate.)
|
|||
|
|
|
|||
|
|
The shapes of ``input`` and ``other`` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the first input tensor
|
|||
|
|
other (Tensor): the second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 0.9041, 0.0196, -0.3108, -2.4423])
|
|||
|
|
>>> torch.atan2(a, torch.randn(4))
|
|||
|
|
tensor([ 0.9833, 0.0811, -1.9743, -1.4151])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def atan_(input: Tensor) -> Tensor: ...
|
|||
|
|
def atanh(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
atanh(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the inverse hyperbolic tangent of the elements of :attr:`input`.
|
|||
|
|
|
|||
|
|
Note:
|
|||
|
|
The domain of the inverse hyperbolic tangent is `(-1, 1)` and values outside this range
|
|||
|
|
will be mapped to ``NaN``, except for the values `1` and `-1` for which the output is
|
|||
|
|
mapped to `+/-INF` respectively.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \tanh^{-1}(\text{input}_{i})
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4).uniform_(-1, 1)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ -0.9385, 0.2968, -0.8591, -0.1871 ])
|
|||
|
|
>>> torch.atanh(a)
|
|||
|
|
tensor([ -1.7253, 0.3060, -1.2899, -0.1893 ])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def atanh_(input: Tensor) -> Tensor: ...
|
|||
|
|
def avg_pool1d(input: Tensor, kernel_size: Union[_int, _size], stride: Union[_int, _size] = (), padding: Union[_int, _size] = 0, ceil_mode: _bool = False, count_include_pad: _bool = True) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def baddbmm(beta: Union[Number, _complex], self: Tensor, alpha: Union[Number, _complex], batch1: Tensor, batch2: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
baddbmm(input, batch1, batch2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a batch matrix-matrix product of matrices in :attr:`batch1`
|
|||
|
|
and :attr:`batch2`.
|
|||
|
|
:attr:`input` is added to the final result.
|
|||
|
|
|
|||
|
|
:attr:`batch1` and :attr:`batch2` must be 3-D tensors each containing the same
|
|||
|
|
number of matrices.
|
|||
|
|
|
|||
|
|
If :attr:`batch1` is a :math:`(b \times n \times m)` tensor, :attr:`batch2` is a
|
|||
|
|
:math:`(b \times m \times p)` tensor, then :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a
|
|||
|
|
:math:`(b \times n \times p)` tensor and :attr:`out` will be a
|
|||
|
|
:math:`(b \times n \times p)` tensor. Both :attr:`alpha` and :attr:`beta` mean the
|
|||
|
|
same as the scaling factors used in :meth:`torch.addbmm`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \beta\ \text{input}_i + \alpha\ (\text{batch1}_i \mathbin{@} \text{batch2}_i)
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, arguments :attr:`beta` and
|
|||
|
|
:attr:`alpha` must be real numbers, otherwise they should be integers.
|
|||
|
|
|
|||
|
|
This operator supports :ref:`TensorFloat32<tf32_on_ampere>`.
|
|||
|
|
|
|||
|
|
On certain ROCm devices, when using float16 inputs this module will use :ref:`different precision<fp16_on_mi200>` for backward.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to be added
|
|||
|
|
batch1 (Tensor): the first batch of matrices to be multiplied
|
|||
|
|
batch2 (Tensor): the second batch of matrices to be multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`\text{batch1} \mathbin{@} \text{batch2}` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> M = torch.randn(10, 3, 5)
|
|||
|
|
>>> batch1 = torch.randn(10, 3, 4)
|
|||
|
|
>>> batch2 = torch.randn(10, 4, 5)
|
|||
|
|
>>> torch.baddbmm(M, batch1, batch2).size()
|
|||
|
|
torch.Size([10, 3, 5])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def baddbmm(beta: Union[Number, _complex], self: Tensor, alpha: Union[Number, _complex], batch1: Tensor, batch2: Tensor, *, out: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
baddbmm(input, batch1, batch2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a batch matrix-matrix product of matrices in :attr:`batch1`
|
|||
|
|
and :attr:`batch2`.
|
|||
|
|
:attr:`input` is added to the final result.
|
|||
|
|
|
|||
|
|
:attr:`batch1` and :attr:`batch2` must be 3-D tensors each containing the same
|
|||
|
|
number of matrices.
|
|||
|
|
|
|||
|
|
If :attr:`batch1` is a :math:`(b \times n \times m)` tensor, :attr:`batch2` is a
|
|||
|
|
:math:`(b \times m \times p)` tensor, then :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a
|
|||
|
|
:math:`(b \times n \times p)` tensor and :attr:`out` will be a
|
|||
|
|
:math:`(b \times n \times p)` tensor. Both :attr:`alpha` and :attr:`beta` mean the
|
|||
|
|
same as the scaling factors used in :meth:`torch.addbmm`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \beta\ \text{input}_i + \alpha\ (\text{batch1}_i \mathbin{@} \text{batch2}_i)
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, arguments :attr:`beta` and
|
|||
|
|
:attr:`alpha` must be real numbers, otherwise they should be integers.
|
|||
|
|
|
|||
|
|
This operator supports :ref:`TensorFloat32<tf32_on_ampere>`.
|
|||
|
|
|
|||
|
|
On certain ROCm devices, when using float16 inputs this module will use :ref:`different precision<fp16_on_mi200>` for backward.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to be added
|
|||
|
|
batch1 (Tensor): the first batch of matrices to be multiplied
|
|||
|
|
batch2 (Tensor): the second batch of matrices to be multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`\text{batch1} \mathbin{@} \text{batch2}` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> M = torch.randn(10, 3, 5)
|
|||
|
|
>>> batch1 = torch.randn(10, 3, 4)
|
|||
|
|
>>> batch2 = torch.randn(10, 4, 5)
|
|||
|
|
>>> torch.baddbmm(M, batch1, batch2).size()
|
|||
|
|
torch.Size([10, 3, 5])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def baddbmm(input: Tensor, batch1: Tensor, batch2: Tensor, *, beta: Union[Number, _complex] = 1, alpha: Union[Number, _complex] = 1, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
baddbmm(input, batch1, batch2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a batch matrix-matrix product of matrices in :attr:`batch1`
|
|||
|
|
and :attr:`batch2`.
|
|||
|
|
:attr:`input` is added to the final result.
|
|||
|
|
|
|||
|
|
:attr:`batch1` and :attr:`batch2` must be 3-D tensors each containing the same
|
|||
|
|
number of matrices.
|
|||
|
|
|
|||
|
|
If :attr:`batch1` is a :math:`(b \times n \times m)` tensor, :attr:`batch2` is a
|
|||
|
|
:math:`(b \times m \times p)` tensor, then :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a
|
|||
|
|
:math:`(b \times n \times p)` tensor and :attr:`out` will be a
|
|||
|
|
:math:`(b \times n \times p)` tensor. Both :attr:`alpha` and :attr:`beta` mean the
|
|||
|
|
same as the scaling factors used in :meth:`torch.addbmm`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \beta\ \text{input}_i + \alpha\ (\text{batch1}_i \mathbin{@} \text{batch2}_i)
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, arguments :attr:`beta` and
|
|||
|
|
:attr:`alpha` must be real numbers, otherwise they should be integers.
|
|||
|
|
|
|||
|
|
This operator supports :ref:`TensorFloat32<tf32_on_ampere>`.
|
|||
|
|
|
|||
|
|
On certain ROCm devices, when using float16 inputs this module will use :ref:`different precision<fp16_on_mi200>` for backward.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to be added
|
|||
|
|
batch1 (Tensor): the first batch of matrices to be multiplied
|
|||
|
|
batch2 (Tensor): the second batch of matrices to be multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`\text{batch1} \mathbin{@} \text{batch2}` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> M = torch.randn(10, 3, 5)
|
|||
|
|
>>> batch1 = torch.randn(10, 3, 4)
|
|||
|
|
>>> batch2 = torch.randn(10, 4, 5)
|
|||
|
|
>>> torch.baddbmm(M, batch1, batch2).size()
|
|||
|
|
torch.Size([10, 3, 5])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def baddbmm(beta: Union[Number, _complex], self: Tensor, batch1: Tensor, batch2: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
baddbmm(input, batch1, batch2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a batch matrix-matrix product of matrices in :attr:`batch1`
|
|||
|
|
and :attr:`batch2`.
|
|||
|
|
:attr:`input` is added to the final result.
|
|||
|
|
|
|||
|
|
:attr:`batch1` and :attr:`batch2` must be 3-D tensors each containing the same
|
|||
|
|
number of matrices.
|
|||
|
|
|
|||
|
|
If :attr:`batch1` is a :math:`(b \times n \times m)` tensor, :attr:`batch2` is a
|
|||
|
|
:math:`(b \times m \times p)` tensor, then :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a
|
|||
|
|
:math:`(b \times n \times p)` tensor and :attr:`out` will be a
|
|||
|
|
:math:`(b \times n \times p)` tensor. Both :attr:`alpha` and :attr:`beta` mean the
|
|||
|
|
same as the scaling factors used in :meth:`torch.addbmm`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \beta\ \text{input}_i + \alpha\ (\text{batch1}_i \mathbin{@} \text{batch2}_i)
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, arguments :attr:`beta` and
|
|||
|
|
:attr:`alpha` must be real numbers, otherwise they should be integers.
|
|||
|
|
|
|||
|
|
This operator supports :ref:`TensorFloat32<tf32_on_ampere>`.
|
|||
|
|
|
|||
|
|
On certain ROCm devices, when using float16 inputs this module will use :ref:`different precision<fp16_on_mi200>` for backward.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to be added
|
|||
|
|
batch1 (Tensor): the first batch of matrices to be multiplied
|
|||
|
|
batch2 (Tensor): the second batch of matrices to be multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`\text{batch1} \mathbin{@} \text{batch2}` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> M = torch.randn(10, 3, 5)
|
|||
|
|
>>> batch1 = torch.randn(10, 3, 4)
|
|||
|
|
>>> batch2 = torch.randn(10, 4, 5)
|
|||
|
|
>>> torch.baddbmm(M, batch1, batch2).size()
|
|||
|
|
torch.Size([10, 3, 5])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def baddbmm(beta: Union[Number, _complex], self: Tensor, batch1: Tensor, batch2: Tensor, *, out: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
baddbmm(input, batch1, batch2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a batch matrix-matrix product of matrices in :attr:`batch1`
|
|||
|
|
and :attr:`batch2`.
|
|||
|
|
:attr:`input` is added to the final result.
|
|||
|
|
|
|||
|
|
:attr:`batch1` and :attr:`batch2` must be 3-D tensors each containing the same
|
|||
|
|
number of matrices.
|
|||
|
|
|
|||
|
|
If :attr:`batch1` is a :math:`(b \times n \times m)` tensor, :attr:`batch2` is a
|
|||
|
|
:math:`(b \times m \times p)` tensor, then :attr:`input` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with a
|
|||
|
|
:math:`(b \times n \times p)` tensor and :attr:`out` will be a
|
|||
|
|
:math:`(b \times n \times p)` tensor. Both :attr:`alpha` and :attr:`beta` mean the
|
|||
|
|
same as the scaling factors used in :meth:`torch.addbmm`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \beta\ \text{input}_i + \alpha\ (\text{batch1}_i \mathbin{@} \text{batch2}_i)
|
|||
|
|
|
|||
|
|
If :attr:`beta` is 0, then :attr:`input` will be ignored, and `nan` and `inf` in
|
|||
|
|
it will not be propagated.
|
|||
|
|
|
|||
|
|
For inputs of type `FloatTensor` or `DoubleTensor`, arguments :attr:`beta` and
|
|||
|
|
:attr:`alpha` must be real numbers, otherwise they should be integers.
|
|||
|
|
|
|||
|
|
This operator supports :ref:`TensorFloat32<tf32_on_ampere>`.
|
|||
|
|
|
|||
|
|
On certain ROCm devices, when using float16 inputs this module will use :ref:`different precision<fp16_on_mi200>` for backward.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to be added
|
|||
|
|
batch1 (Tensor): the first batch of matrices to be multiplied
|
|||
|
|
batch2 (Tensor): the second batch of matrices to be multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`input` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`\text{batch1} \mathbin{@} \text{batch2}` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> M = torch.randn(10, 3, 5)
|
|||
|
|
>>> batch1 = torch.randn(10, 3, 4)
|
|||
|
|
>>> batch2 = torch.randn(10, 4, 5)
|
|||
|
|
>>> torch.baddbmm(M, batch1, batch2).size()
|
|||
|
|
torch.Size([10, 3, 5])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def bartlett_window(window_length: _int, *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bartlett_window(window_length, periodic=True, *, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Bartlett window function.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
w[n] = 1 - \left| \frac{2n}{N-1} - 1 \right| = \begin{cases}
|
|||
|
|
\frac{2n}{N - 1} & \text{if } 0 \leq n \leq \frac{N - 1}{2} \\
|
|||
|
|
2 - \frac{2n}{N - 1} & \text{if } \frac{N - 1}{2} < n < N \\
|
|||
|
|
\end{cases},
|
|||
|
|
|
|||
|
|
where :math:`N` is the full window size.
|
|||
|
|
|
|||
|
|
The input :attr:`window_length` is a positive integer controlling the
|
|||
|
|
returned window size. :attr:`periodic` flag determines whether the returned
|
|||
|
|
window trims off the last duplicate value from the symmetric window and is
|
|||
|
|
ready to be used as a periodic window with functions like
|
|||
|
|
:meth:`torch.stft`. Therefore, if :attr:`periodic` is true, the :math:`N` in
|
|||
|
|
above formula is in fact :math:`\text{window\_length} + 1`. Also, we always have
|
|||
|
|
``torch.bartlett_window(L, periodic=True)`` equal to
|
|||
|
|
``torch.bartlett_window(L + 1, periodic=False)[:-1])``.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If :attr:`window_length` :math:`=1`, the returned window contains a single value 1.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
window_length (int): the size of returned window
|
|||
|
|
periodic (bool, optional): If True, returns a window to be used as periodic
|
|||
|
|
function. If False, return a symmetric window.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`). Only floating point types are supported.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned window tensor. Only
|
|||
|
|
``torch.strided`` (dense layout) is supported.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A 1-D tensor of size :math:`(\text{window\_length},)` containing the window
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def bartlett_window(window_length: _int, periodic: _bool, *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bartlett_window(window_length, periodic=True, *, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Bartlett window function.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
w[n] = 1 - \left| \frac{2n}{N-1} - 1 \right| = \begin{cases}
|
|||
|
|
\frac{2n}{N - 1} & \text{if } 0 \leq n \leq \frac{N - 1}{2} \\
|
|||
|
|
2 - \frac{2n}{N - 1} & \text{if } \frac{N - 1}{2} < n < N \\
|
|||
|
|
\end{cases},
|
|||
|
|
|
|||
|
|
where :math:`N` is the full window size.
|
|||
|
|
|
|||
|
|
The input :attr:`window_length` is a positive integer controlling the
|
|||
|
|
returned window size. :attr:`periodic` flag determines whether the returned
|
|||
|
|
window trims off the last duplicate value from the symmetric window and is
|
|||
|
|
ready to be used as a periodic window with functions like
|
|||
|
|
:meth:`torch.stft`. Therefore, if :attr:`periodic` is true, the :math:`N` in
|
|||
|
|
above formula is in fact :math:`\text{window\_length} + 1`. Also, we always have
|
|||
|
|
``torch.bartlett_window(L, periodic=True)`` equal to
|
|||
|
|
``torch.bartlett_window(L + 1, periodic=False)[:-1])``.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If :attr:`window_length` :math:`=1`, the returned window contains a single value 1.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
window_length (int): the size of returned window
|
|||
|
|
periodic (bool, optional): If True, returns a window to be used as periodic
|
|||
|
|
function. If False, return a symmetric window.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`). Only floating point types are supported.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned window tensor. Only
|
|||
|
|
``torch.strided`` (dense layout) is supported.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A 1-D tensor of size :math:`(\text{window\_length},)` containing the window
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def batch_norm(input: Tensor, weight: Optional[Tensor], bias: Optional[Tensor], running_mean: Optional[Tensor], running_var: Optional[Tensor], training: _bool, momentum: _float, eps: _float, cudnn_enabled: _bool) -> Tensor: ...
|
|||
|
|
def batch_norm_backward_elemt(grad_out: Tensor, input: Tensor, mean: Tensor, invstd: Tensor, weight: Optional[Tensor], sum_dy: Tensor, sum_dy_xmu: Tensor, count: Tensor) -> Tensor: ...
|
|||
|
|
def batch_norm_backward_reduce(grad_out: Tensor, input: Tensor, mean: Tensor, invstd: Tensor, weight: Optional[Tensor], input_g: _bool, weight_g: _bool, bias_g: _bool) -> Tuple[Tensor, Tensor, Tensor, Tensor]: ...
|
|||
|
|
def batch_norm_elemt(input: Tensor, weight: Optional[Tensor], bias: Optional[Tensor], mean: Tensor, invstd: Tensor, eps: _float, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def batch_norm_gather_stats(input: Tensor, mean: Tensor, invstd: Tensor, running_mean: Optional[Tensor], running_var: Optional[Tensor], momentum: _float, eps: _float, count: _int) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def batch_norm_gather_stats_with_counts(input: Tensor, mean: Tensor, invstd: Tensor, running_mean: Optional[Tensor], running_var: Optional[Tensor], momentum: _float, eps: _float, counts: Tensor) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def batch_norm_stats(input: Tensor, eps: _float) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def batch_norm_update_stats(input: Tensor, running_mean: Optional[Tensor], running_var: Optional[Tensor], momentum: _float) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
@overload
|
|||
|
|
def bernoulli(input: Tensor, *, generator: Optional[Generator] = None, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bernoulli(input, *, generator=None, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Draws binary random numbers (0 or 1) from a Bernoulli distribution.
|
|||
|
|
|
|||
|
|
The :attr:`input` tensor should be a tensor containing probabilities
|
|||
|
|
to be used for drawing the binary random number.
|
|||
|
|
Hence, all values in :attr:`input` have to be in the range:
|
|||
|
|
:math:`0 \leq \text{input}_i \leq 1`.
|
|||
|
|
|
|||
|
|
The :math:`\text{i}^{th}` element of the output tensor will draw a
|
|||
|
|
value :math:`1` according to the :math:`\text{i}^{th}` probability value given
|
|||
|
|
in :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} \sim \mathrm{Bernoulli}(p = \text{input}_{i})
|
|||
|
|
|
|||
|
|
The returned :attr:`out` tensor only has values 0 or 1 and is of the same
|
|||
|
|
shape as :attr:`input`.
|
|||
|
|
|
|||
|
|
:attr:`out` can have integral ``dtype``, but :attr:`input` must have floating
|
|||
|
|
point ``dtype``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor of probability values for the Bernoulli distribution
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.empty(3, 3).uniform_(0, 1) # generate a uniform random matrix with range [0, 1]
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.1737, 0.0950, 0.3609],
|
|||
|
|
[ 0.7148, 0.0289, 0.2676],
|
|||
|
|
[ 0.9456, 0.8937, 0.7202]])
|
|||
|
|
>>> torch.bernoulli(a)
|
|||
|
|
tensor([[ 1., 0., 0.],
|
|||
|
|
[ 0., 0., 0.],
|
|||
|
|
[ 1., 1., 1.]])
|
|||
|
|
|
|||
|
|
>>> a = torch.ones(3, 3) # probability of drawing "1" is 1
|
|||
|
|
>>> torch.bernoulli(a)
|
|||
|
|
tensor([[ 1., 1., 1.],
|
|||
|
|
[ 1., 1., 1.],
|
|||
|
|
[ 1., 1., 1.]])
|
|||
|
|
>>> a = torch.zeros(3, 3) # probability of drawing "1" is 0
|
|||
|
|
>>> torch.bernoulli(a)
|
|||
|
|
tensor([[ 0., 0., 0.],
|
|||
|
|
[ 0., 0., 0.],
|
|||
|
|
[ 0., 0., 0.]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def bernoulli(input: Tensor, p: _float, *, generator: Optional[Generator] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bernoulli(input, *, generator=None, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Draws binary random numbers (0 or 1) from a Bernoulli distribution.
|
|||
|
|
|
|||
|
|
The :attr:`input` tensor should be a tensor containing probabilities
|
|||
|
|
to be used for drawing the binary random number.
|
|||
|
|
Hence, all values in :attr:`input` have to be in the range:
|
|||
|
|
:math:`0 \leq \text{input}_i \leq 1`.
|
|||
|
|
|
|||
|
|
The :math:`\text{i}^{th}` element of the output tensor will draw a
|
|||
|
|
value :math:`1` according to the :math:`\text{i}^{th}` probability value given
|
|||
|
|
in :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} \sim \mathrm{Bernoulli}(p = \text{input}_{i})
|
|||
|
|
|
|||
|
|
The returned :attr:`out` tensor only has values 0 or 1 and is of the same
|
|||
|
|
shape as :attr:`input`.
|
|||
|
|
|
|||
|
|
:attr:`out` can have integral ``dtype``, but :attr:`input` must have floating
|
|||
|
|
point ``dtype``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor of probability values for the Bernoulli distribution
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.empty(3, 3).uniform_(0, 1) # generate a uniform random matrix with range [0, 1]
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.1737, 0.0950, 0.3609],
|
|||
|
|
[ 0.7148, 0.0289, 0.2676],
|
|||
|
|
[ 0.9456, 0.8937, 0.7202]])
|
|||
|
|
>>> torch.bernoulli(a)
|
|||
|
|
tensor([[ 1., 0., 0.],
|
|||
|
|
[ 0., 0., 0.],
|
|||
|
|
[ 1., 1., 1.]])
|
|||
|
|
|
|||
|
|
>>> a = torch.ones(3, 3) # probability of drawing "1" is 1
|
|||
|
|
>>> torch.bernoulli(a)
|
|||
|
|
tensor([[ 1., 1., 1.],
|
|||
|
|
[ 1., 1., 1.],
|
|||
|
|
[ 1., 1., 1.]])
|
|||
|
|
>>> a = torch.zeros(3, 3) # probability of drawing "1" is 0
|
|||
|
|
>>> torch.bernoulli(a)
|
|||
|
|
tensor([[ 0., 0., 0.],
|
|||
|
|
[ 0., 0., 0.],
|
|||
|
|
[ 0., 0., 0.]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def bilinear(input1: Tensor, input2: Tensor, weight: Tensor, bias: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def binary_cross_entropy_with_logits(input: Tensor, target: Tensor, weight: Optional[Tensor] = None, pos_weight: Optional[Tensor] = None, reduction: _int = 1) -> Tensor: ...
|
|||
|
|
def bincount(input: Tensor, weights: Optional[Tensor] = None, minlength: _int = 0) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bincount(input, weights=None, minlength=0) -> Tensor
|
|||
|
|
|
|||
|
|
Count the frequency of each value in an array of non-negative ints.
|
|||
|
|
|
|||
|
|
The number of bins (size 1) is one larger than the largest value in
|
|||
|
|
:attr:`input` unless :attr:`input` is empty, in which case the result is a
|
|||
|
|
tensor of size 0. If :attr:`minlength` is specified, the number of bins is at least
|
|||
|
|
:attr:`minlength` and if :attr:`input` is empty, then the result is tensor of size
|
|||
|
|
:attr:`minlength` filled with zeros. If ``n`` is the value at position ``i``,
|
|||
|
|
``out[n] += weights[i]`` if :attr:`weights` is specified else
|
|||
|
|
``out[n] += 1``.
|
|||
|
|
|
|||
|
|
Note:
|
|||
|
|
This operation may produce nondeterministic gradients when given tensors on a CUDA device. See :doc:`/notes/randomness` for more information.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
input (Tensor): 1-d int tensor
|
|||
|
|
weights (Tensor): optional, weight for each value in the input tensor.
|
|||
|
|
Should be of same size as input tensor.
|
|||
|
|
minlength (int): optional, minimum number of bins. Should be non-negative.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
output (Tensor): a tensor of shape ``Size([max(input) + 1])`` if
|
|||
|
|
:attr:`input` is non-empty, else ``Size(0)``
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> input = torch.randint(0, 8, (5,), dtype=torch.int64)
|
|||
|
|
>>> weights = torch.linspace(0, 1, steps=5)
|
|||
|
|
>>> input, weights
|
|||
|
|
(tensor([4, 3, 6, 3, 4]),
|
|||
|
|
tensor([ 0.0000, 0.2500, 0.5000, 0.7500, 1.0000])
|
|||
|
|
|
|||
|
|
>>> torch.bincount(input)
|
|||
|
|
tensor([0, 0, 0, 2, 2, 0, 1])
|
|||
|
|
|
|||
|
|
>>> input.bincount(weights)
|
|||
|
|
tensor([0.0000, 0.0000, 0.0000, 1.0000, 1.0000, 0.0000, 0.5000])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def binomial(count: Tensor, prob: Tensor, generator: Optional[Generator] = None) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def bitwise_and(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bitwise_and(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the bitwise AND of :attr:`input` and :attr:`other`. The input tensor must be of
|
|||
|
|
integral or Boolean types. For bool tensors, it computes the logical AND.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input: the first input tensor
|
|||
|
|
other: the second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.bitwise_and(torch.tensor([-1, -2, 3], dtype=torch.int8), torch.tensor([1, 0, 3], dtype=torch.int8))
|
|||
|
|
tensor([1, 0, 3], dtype=torch.int8)
|
|||
|
|
>>> torch.bitwise_and(torch.tensor([True, True, False]), torch.tensor([False, True, False]))
|
|||
|
|
tensor([ False, True, False])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def bitwise_and(self: Union[Number, _complex], other: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bitwise_and(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the bitwise AND of :attr:`input` and :attr:`other`. The input tensor must be of
|
|||
|
|
integral or Boolean types. For bool tensors, it computes the logical AND.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input: the first input tensor
|
|||
|
|
other: the second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.bitwise_and(torch.tensor([-1, -2, 3], dtype=torch.int8), torch.tensor([1, 0, 3], dtype=torch.int8))
|
|||
|
|
tensor([1, 0, 3], dtype=torch.int8)
|
|||
|
|
>>> torch.bitwise_and(torch.tensor([True, True, False]), torch.tensor([False, True, False]))
|
|||
|
|
tensor([ False, True, False])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def bitwise_and(input: Tensor, other: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bitwise_and(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the bitwise AND of :attr:`input` and :attr:`other`. The input tensor must be of
|
|||
|
|
integral or Boolean types. For bool tensors, it computes the logical AND.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input: the first input tensor
|
|||
|
|
other: the second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.bitwise_and(torch.tensor([-1, -2, 3], dtype=torch.int8), torch.tensor([1, 0, 3], dtype=torch.int8))
|
|||
|
|
tensor([1, 0, 3], dtype=torch.int8)
|
|||
|
|
>>> torch.bitwise_and(torch.tensor([True, True, False]), torch.tensor([False, True, False]))
|
|||
|
|
tensor([ False, True, False])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def bitwise_left_shift(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bitwise_left_shift(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the left arithmetic shift of :attr:`input` by :attr:`other` bits.
|
|||
|
|
The input tensor must be of integral type. This operator supports
|
|||
|
|
:ref:`broadcasting to a common shape <broadcasting-semantics>` and
|
|||
|
|
:ref:`type promotion <type-promotion-doc>`.
|
|||
|
|
|
|||
|
|
The operation applied is:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \text{input}_i << \text{other}_i
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor or Scalar): the first input tensor
|
|||
|
|
other (Tensor or Scalar): the second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.bitwise_left_shift(torch.tensor([-1, -2, 3], dtype=torch.int8), torch.tensor([1, 0, 3], dtype=torch.int8))
|
|||
|
|
tensor([-2, -2, 24], dtype=torch.int8)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def bitwise_left_shift(self: Union[Number, _complex], other: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bitwise_left_shift(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the left arithmetic shift of :attr:`input` by :attr:`other` bits.
|
|||
|
|
The input tensor must be of integral type. This operator supports
|
|||
|
|
:ref:`broadcasting to a common shape <broadcasting-semantics>` and
|
|||
|
|
:ref:`type promotion <type-promotion-doc>`.
|
|||
|
|
|
|||
|
|
The operation applied is:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \text{input}_i << \text{other}_i
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor or Scalar): the first input tensor
|
|||
|
|
other (Tensor or Scalar): the second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.bitwise_left_shift(torch.tensor([-1, -2, 3], dtype=torch.int8), torch.tensor([1, 0, 3], dtype=torch.int8))
|
|||
|
|
tensor([-2, -2, 24], dtype=torch.int8)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def bitwise_left_shift(input: Tensor, other: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bitwise_left_shift(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the left arithmetic shift of :attr:`input` by :attr:`other` bits.
|
|||
|
|
The input tensor must be of integral type. This operator supports
|
|||
|
|
:ref:`broadcasting to a common shape <broadcasting-semantics>` and
|
|||
|
|
:ref:`type promotion <type-promotion-doc>`.
|
|||
|
|
|
|||
|
|
The operation applied is:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \text{input}_i << \text{other}_i
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor or Scalar): the first input tensor
|
|||
|
|
other (Tensor or Scalar): the second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.bitwise_left_shift(torch.tensor([-1, -2, 3], dtype=torch.int8), torch.tensor([1, 0, 3], dtype=torch.int8))
|
|||
|
|
tensor([-2, -2, 24], dtype=torch.int8)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def bitwise_not(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bitwise_not(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the bitwise NOT of the given input tensor. The input tensor must be of
|
|||
|
|
integral or Boolean types. For bool tensors, it computes the logical NOT.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.bitwise_not(torch.tensor([-1, -2, 3], dtype=torch.int8))
|
|||
|
|
tensor([ 0, 1, -4], dtype=torch.int8)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def bitwise_or(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bitwise_or(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the bitwise OR of :attr:`input` and :attr:`other`. The input tensor must be of
|
|||
|
|
integral or Boolean types. For bool tensors, it computes the logical OR.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input: the first input tensor
|
|||
|
|
other: the second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.bitwise_or(torch.tensor([-1, -2, 3], dtype=torch.int8), torch.tensor([1, 0, 3], dtype=torch.int8))
|
|||
|
|
tensor([-1, -2, 3], dtype=torch.int8)
|
|||
|
|
>>> torch.bitwise_or(torch.tensor([True, True, False]), torch.tensor([False, True, False]))
|
|||
|
|
tensor([ True, True, False])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def bitwise_or(self: Union[Number, _complex], other: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bitwise_or(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the bitwise OR of :attr:`input` and :attr:`other`. The input tensor must be of
|
|||
|
|
integral or Boolean types. For bool tensors, it computes the logical OR.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input: the first input tensor
|
|||
|
|
other: the second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.bitwise_or(torch.tensor([-1, -2, 3], dtype=torch.int8), torch.tensor([1, 0, 3], dtype=torch.int8))
|
|||
|
|
tensor([-1, -2, 3], dtype=torch.int8)
|
|||
|
|
>>> torch.bitwise_or(torch.tensor([True, True, False]), torch.tensor([False, True, False]))
|
|||
|
|
tensor([ True, True, False])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def bitwise_or(input: Tensor, other: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bitwise_or(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the bitwise OR of :attr:`input` and :attr:`other`. The input tensor must be of
|
|||
|
|
integral or Boolean types. For bool tensors, it computes the logical OR.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input: the first input tensor
|
|||
|
|
other: the second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.bitwise_or(torch.tensor([-1, -2, 3], dtype=torch.int8), torch.tensor([1, 0, 3], dtype=torch.int8))
|
|||
|
|
tensor([-1, -2, 3], dtype=torch.int8)
|
|||
|
|
>>> torch.bitwise_or(torch.tensor([True, True, False]), torch.tensor([False, True, False]))
|
|||
|
|
tensor([ True, True, False])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def bitwise_right_shift(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bitwise_right_shift(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the right arithmetic shift of :attr:`input` by :attr:`other` bits.
|
|||
|
|
The input tensor must be of integral type. This operator supports
|
|||
|
|
:ref:`broadcasting to a common shape <broadcasting-semantics>` and
|
|||
|
|
:ref:`type promotion <type-promotion-doc>`.
|
|||
|
|
In any case, if the value of the right operand is negative or is greater
|
|||
|
|
or equal to the number of bits in the promoted left operand, the behavior is undefined.
|
|||
|
|
|
|||
|
|
The operation applied is:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \text{input}_i >> \text{other}_i
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor or Scalar): the first input tensor
|
|||
|
|
other (Tensor or Scalar): the second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.bitwise_right_shift(torch.tensor([-2, -7, 31], dtype=torch.int8), torch.tensor([1, 0, 3], dtype=torch.int8))
|
|||
|
|
tensor([-1, -7, 3], dtype=torch.int8)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def bitwise_right_shift(self: Union[Number, _complex], other: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bitwise_right_shift(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the right arithmetic shift of :attr:`input` by :attr:`other` bits.
|
|||
|
|
The input tensor must be of integral type. This operator supports
|
|||
|
|
:ref:`broadcasting to a common shape <broadcasting-semantics>` and
|
|||
|
|
:ref:`type promotion <type-promotion-doc>`.
|
|||
|
|
In any case, if the value of the right operand is negative or is greater
|
|||
|
|
or equal to the number of bits in the promoted left operand, the behavior is undefined.
|
|||
|
|
|
|||
|
|
The operation applied is:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \text{input}_i >> \text{other}_i
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor or Scalar): the first input tensor
|
|||
|
|
other (Tensor or Scalar): the second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.bitwise_right_shift(torch.tensor([-2, -7, 31], dtype=torch.int8), torch.tensor([1, 0, 3], dtype=torch.int8))
|
|||
|
|
tensor([-1, -7, 3], dtype=torch.int8)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def bitwise_right_shift(input: Tensor, other: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bitwise_right_shift(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the right arithmetic shift of :attr:`input` by :attr:`other` bits.
|
|||
|
|
The input tensor must be of integral type. This operator supports
|
|||
|
|
:ref:`broadcasting to a common shape <broadcasting-semantics>` and
|
|||
|
|
:ref:`type promotion <type-promotion-doc>`.
|
|||
|
|
In any case, if the value of the right operand is negative or is greater
|
|||
|
|
or equal to the number of bits in the promoted left operand, the behavior is undefined.
|
|||
|
|
|
|||
|
|
The operation applied is:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \text{input}_i >> \text{other}_i
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor or Scalar): the first input tensor
|
|||
|
|
other (Tensor or Scalar): the second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.bitwise_right_shift(torch.tensor([-2, -7, 31], dtype=torch.int8), torch.tensor([1, 0, 3], dtype=torch.int8))
|
|||
|
|
tensor([-1, -7, 3], dtype=torch.int8)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def bitwise_xor(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bitwise_xor(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the bitwise XOR of :attr:`input` and :attr:`other`. The input tensor must be of
|
|||
|
|
integral or Boolean types. For bool tensors, it computes the logical XOR.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input: the first input tensor
|
|||
|
|
other: the second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.bitwise_xor(torch.tensor([-1, -2, 3], dtype=torch.int8), torch.tensor([1, 0, 3], dtype=torch.int8))
|
|||
|
|
tensor([-2, -2, 0], dtype=torch.int8)
|
|||
|
|
>>> torch.bitwise_xor(torch.tensor([True, True, False]), torch.tensor([False, True, False]))
|
|||
|
|
tensor([ True, False, False])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def bitwise_xor(self: Union[Number, _complex], other: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bitwise_xor(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the bitwise XOR of :attr:`input` and :attr:`other`. The input tensor must be of
|
|||
|
|
integral or Boolean types. For bool tensors, it computes the logical XOR.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input: the first input tensor
|
|||
|
|
other: the second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.bitwise_xor(torch.tensor([-1, -2, 3], dtype=torch.int8), torch.tensor([1, 0, 3], dtype=torch.int8))
|
|||
|
|
tensor([-2, -2, 0], dtype=torch.int8)
|
|||
|
|
>>> torch.bitwise_xor(torch.tensor([True, True, False]), torch.tensor([False, True, False]))
|
|||
|
|
tensor([ True, False, False])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def bitwise_xor(input: Tensor, other: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bitwise_xor(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the bitwise XOR of :attr:`input` and :attr:`other`. The input tensor must be of
|
|||
|
|
integral or Boolean types. For bool tensors, it computes the logical XOR.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input: the first input tensor
|
|||
|
|
other: the second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.bitwise_xor(torch.tensor([-1, -2, 3], dtype=torch.int8), torch.tensor([1, 0, 3], dtype=torch.int8))
|
|||
|
|
tensor([-2, -2, 0], dtype=torch.int8)
|
|||
|
|
>>> torch.bitwise_xor(torch.tensor([True, True, False]), torch.tensor([False, True, False]))
|
|||
|
|
tensor([ True, False, False])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def blackman_window(window_length: _int, *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
blackman_window(window_length, periodic=True, *, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Blackman window function.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
w[n] = 0.42 - 0.5 \cos \left( \frac{2 \pi n}{N - 1} \right) + 0.08 \cos \left( \frac{4 \pi n}{N - 1} \right)
|
|||
|
|
|
|||
|
|
where :math:`N` is the full window size.
|
|||
|
|
|
|||
|
|
The input :attr:`window_length` is a positive integer controlling the
|
|||
|
|
returned window size. :attr:`periodic` flag determines whether the returned
|
|||
|
|
window trims off the last duplicate value from the symmetric window and is
|
|||
|
|
ready to be used as a periodic window with functions like
|
|||
|
|
:meth:`torch.stft`. Therefore, if :attr:`periodic` is true, the :math:`N` in
|
|||
|
|
above formula is in fact :math:`\text{window\_length} + 1`. Also, we always have
|
|||
|
|
``torch.blackman_window(L, periodic=True)`` equal to
|
|||
|
|
``torch.blackman_window(L + 1, periodic=False)[:-1])``.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If :attr:`window_length` :math:`=1`, the returned window contains a single value 1.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
window_length (int): the size of returned window
|
|||
|
|
periodic (bool, optional): If True, returns a window to be used as periodic
|
|||
|
|
function. If False, return a symmetric window.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`). Only floating point types are supported.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned window tensor. Only
|
|||
|
|
``torch.strided`` (dense layout) is supported.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A 1-D tensor of size :math:`(\text{window\_length},)` containing the window
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def blackman_window(window_length: _int, periodic: _bool, *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
blackman_window(window_length, periodic=True, *, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Blackman window function.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
w[n] = 0.42 - 0.5 \cos \left( \frac{2 \pi n}{N - 1} \right) + 0.08 \cos \left( \frac{4 \pi n}{N - 1} \right)
|
|||
|
|
|
|||
|
|
where :math:`N` is the full window size.
|
|||
|
|
|
|||
|
|
The input :attr:`window_length` is a positive integer controlling the
|
|||
|
|
returned window size. :attr:`periodic` flag determines whether the returned
|
|||
|
|
window trims off the last duplicate value from the symmetric window and is
|
|||
|
|
ready to be used as a periodic window with functions like
|
|||
|
|
:meth:`torch.stft`. Therefore, if :attr:`periodic` is true, the :math:`N` in
|
|||
|
|
above formula is in fact :math:`\text{window\_length} + 1`. Also, we always have
|
|||
|
|
``torch.blackman_window(L, periodic=True)`` equal to
|
|||
|
|
``torch.blackman_window(L + 1, periodic=False)[:-1])``.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If :attr:`window_length` :math:`=1`, the returned window contains a single value 1.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
window_length (int): the size of returned window
|
|||
|
|
periodic (bool, optional): If True, returns a window to be used as periodic
|
|||
|
|
function. If False, return a symmetric window.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`). Only floating point types are supported.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned window tensor. Only
|
|||
|
|
``torch.strided`` (dense layout) is supported.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A 1-D tensor of size :math:`(\text{window\_length},)` containing the window
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def bmm(input: Tensor, mat2: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bmm(input, mat2, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a batch matrix-matrix product of matrices stored in :attr:`input`
|
|||
|
|
and :attr:`mat2`.
|
|||
|
|
|
|||
|
|
:attr:`input` and :attr:`mat2` must be 3-D tensors each containing
|
|||
|
|
the same number of matrices.
|
|||
|
|
|
|||
|
|
If :attr:`input` is a :math:`(b \times n \times m)` tensor, :attr:`mat2` is a
|
|||
|
|
:math:`(b \times m \times p)` tensor, :attr:`out` will be a
|
|||
|
|
:math:`(b \times n \times p)` tensor.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \text{input}_i \mathbin{@} \text{mat2}_i
|
|||
|
|
|
|||
|
|
This operator supports :ref:`TensorFloat32<tf32_on_ampere>`.
|
|||
|
|
|
|||
|
|
On certain ROCm devices, when using float16 inputs this module will use :ref:`different precision<fp16_on_mi200>` for backward.
|
|||
|
|
|
|||
|
|
.. note:: This function does not :ref:`broadcast <broadcasting-semantics>`.
|
|||
|
|
For broadcasting matrix products, see :func:`torch.matmul`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the first batch of matrices to be multiplied
|
|||
|
|
mat2 (Tensor): the second batch of matrices to be multiplied
|
|||
|
|
|
|||
|
|
Keyword Args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> input = torch.randn(10, 3, 4)
|
|||
|
|
>>> mat2 = torch.randn(10, 4, 5)
|
|||
|
|
>>> res = torch.bmm(input, mat2)
|
|||
|
|
>>> res.size()
|
|||
|
|
torch.Size([10, 3, 5])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def broadcast_to(input: Tensor, size: Sequence[Union[_int, SymInt]]) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
broadcast_to(input, shape) -> Tensor
|
|||
|
|
|
|||
|
|
Broadcasts :attr:`input` to the shape :attr:`\shape`.
|
|||
|
|
Equivalent to calling ``input.expand(shape)``. See :meth:`~Tensor.expand` for details.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
shape (list, tuple, or :class:`torch.Size`): the new shape.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.tensor([1, 2, 3])
|
|||
|
|
>>> torch.broadcast_to(x, (3, 3))
|
|||
|
|
tensor([[1, 2, 3],
|
|||
|
|
[1, 2, 3],
|
|||
|
|
[1, 2, 3]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def bucketize(input: Tensor, boundaries: Tensor, *, out_int32: _bool = False, right: _bool = False, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bucketize(input, boundaries, *, out_int32=False, right=False, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the indices of the buckets to which each value in the :attr:`input` belongs, where the
|
|||
|
|
boundaries of the buckets are set by :attr:`boundaries`. Return a new tensor with the same size
|
|||
|
|
as :attr:`input`. If :attr:`right` is False (default), then the left boundary is open. Note that
|
|||
|
|
this behavior is opposite the behavior of
|
|||
|
|
`numpy.digitize <https://docs.scipy.org/doc/numpy/reference/generated/numpy.digitize.html>`_.
|
|||
|
|
More formally, the returned index satisfies the following rules:
|
|||
|
|
|
|||
|
|
.. list-table::
|
|||
|
|
:widths: 15 85
|
|||
|
|
:header-rows: 1
|
|||
|
|
|
|||
|
|
* - :attr:`right`
|
|||
|
|
- *returned index satisfies*
|
|||
|
|
* - False
|
|||
|
|
- ``boundaries[i-1] < input[m][n]...[l][x] <= boundaries[i]``
|
|||
|
|
* - True
|
|||
|
|
- ``boundaries[i-1] <= input[m][n]...[l][x] < boundaries[i]``
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor or Scalar): N-D tensor or a Scalar containing the search value(s).
|
|||
|
|
boundaries (Tensor): 1-D tensor, must contain a strictly increasing sequence, or the return value is undefined.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out_int32 (bool, optional): indicate the output data type. torch.int32 if True, torch.int64 otherwise.
|
|||
|
|
Default value is False, i.e. default output data type is torch.int64.
|
|||
|
|
right (bool, optional): if False, return the first suitable location that is found. If True, return the
|
|||
|
|
last such index. If no suitable index found, return 0 for non-numerical value
|
|||
|
|
(eg. nan, inf) or the size of :attr:`boundaries` (one pass the last index).
|
|||
|
|
In other words, if False, gets the lower bound index for each value in :attr:`input`
|
|||
|
|
from :attr:`boundaries`. If True, gets the upper bound index instead.
|
|||
|
|
Default value is False.
|
|||
|
|
out (Tensor, optional): the output tensor, must be the same size as :attr:`input` if provided.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> boundaries = torch.tensor([1, 3, 5, 7, 9])
|
|||
|
|
>>> boundaries
|
|||
|
|
tensor([1, 3, 5, 7, 9])
|
|||
|
|
>>> v = torch.tensor([[3, 6, 9], [3, 6, 9]])
|
|||
|
|
>>> v
|
|||
|
|
tensor([[3, 6, 9],
|
|||
|
|
[3, 6, 9]])
|
|||
|
|
>>> torch.bucketize(v, boundaries)
|
|||
|
|
tensor([[1, 3, 4],
|
|||
|
|
[1, 3, 4]])
|
|||
|
|
>>> torch.bucketize(v, boundaries, right=True)
|
|||
|
|
tensor([[2, 3, 5],
|
|||
|
|
[2, 3, 5]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def bucketize(self: Union[Number, _complex], boundaries: Tensor, *, out_int32: _bool = False, right: _bool = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
bucketize(input, boundaries, *, out_int32=False, right=False, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the indices of the buckets to which each value in the :attr:`input` belongs, where the
|
|||
|
|
boundaries of the buckets are set by :attr:`boundaries`. Return a new tensor with the same size
|
|||
|
|
as :attr:`input`. If :attr:`right` is False (default), then the left boundary is open. Note that
|
|||
|
|
this behavior is opposite the behavior of
|
|||
|
|
`numpy.digitize <https://docs.scipy.org/doc/numpy/reference/generated/numpy.digitize.html>`_.
|
|||
|
|
More formally, the returned index satisfies the following rules:
|
|||
|
|
|
|||
|
|
.. list-table::
|
|||
|
|
:widths: 15 85
|
|||
|
|
:header-rows: 1
|
|||
|
|
|
|||
|
|
* - :attr:`right`
|
|||
|
|
- *returned index satisfies*
|
|||
|
|
* - False
|
|||
|
|
- ``boundaries[i-1] < input[m][n]...[l][x] <= boundaries[i]``
|
|||
|
|
* - True
|
|||
|
|
- ``boundaries[i-1] <= input[m][n]...[l][x] < boundaries[i]``
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor or Scalar): N-D tensor or a Scalar containing the search value(s).
|
|||
|
|
boundaries (Tensor): 1-D tensor, must contain a strictly increasing sequence, or the return value is undefined.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out_int32 (bool, optional): indicate the output data type. torch.int32 if True, torch.int64 otherwise.
|
|||
|
|
Default value is False, i.e. default output data type is torch.int64.
|
|||
|
|
right (bool, optional): if False, return the first suitable location that is found. If True, return the
|
|||
|
|
last such index. If no suitable index found, return 0 for non-numerical value
|
|||
|
|
(eg. nan, inf) or the size of :attr:`boundaries` (one pass the last index).
|
|||
|
|
In other words, if False, gets the lower bound index for each value in :attr:`input`
|
|||
|
|
from :attr:`boundaries`. If True, gets the upper bound index instead.
|
|||
|
|
Default value is False.
|
|||
|
|
out (Tensor, optional): the output tensor, must be the same size as :attr:`input` if provided.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> boundaries = torch.tensor([1, 3, 5, 7, 9])
|
|||
|
|
>>> boundaries
|
|||
|
|
tensor([1, 3, 5, 7, 9])
|
|||
|
|
>>> v = torch.tensor([[3, 6, 9], [3, 6, 9]])
|
|||
|
|
>>> v
|
|||
|
|
tensor([[3, 6, 9],
|
|||
|
|
[3, 6, 9]])
|
|||
|
|
>>> torch.bucketize(v, boundaries)
|
|||
|
|
tensor([[1, 3, 4],
|
|||
|
|
[1, 3, 4]])
|
|||
|
|
>>> torch.bucketize(v, boundaries, right=True)
|
|||
|
|
tensor([[2, 3, 5],
|
|||
|
|
[2, 3, 5]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def can_cast(from_: _dtype, to: _dtype) -> _bool:
|
|||
|
|
r"""
|
|||
|
|
can_cast(from, to) -> bool
|
|||
|
|
|
|||
|
|
Determines if a type conversion is allowed under PyTorch casting rules
|
|||
|
|
described in the type promotion :ref:`documentation <type-promotion-doc>`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
from (dtype): The original :class:`torch.dtype`.
|
|||
|
|
to (dtype): The target :class:`torch.dtype`.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.can_cast(torch.double, torch.float)
|
|||
|
|
True
|
|||
|
|
>>> torch.can_cast(torch.float, torch.int)
|
|||
|
|
False
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def cat(tensors: Union[Tuple[Tensor, ...], List[Tensor]], dim: _int = 0, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
cat(tensors, dim=0, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Concatenates the given sequence of :attr:`seq` tensors in the given dimension.
|
|||
|
|
All tensors must either have the same shape (except in the concatenating
|
|||
|
|
dimension) or be a 1-D empty tensor with size ``(0,)``.
|
|||
|
|
|
|||
|
|
:func:`torch.cat` can be seen as an inverse operation for :func:`torch.split`
|
|||
|
|
and :func:`torch.chunk`.
|
|||
|
|
|
|||
|
|
:func:`torch.cat` can be best understood via examples.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.stack` concatenates the given sequence along a new dimension.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
tensors (sequence of Tensors): any python sequence of tensors of the same type.
|
|||
|
|
Non-empty tensors provided must have the same shape, except in the
|
|||
|
|
cat dimension.
|
|||
|
|
dim (int, optional): the dimension over which the tensors are concatenated
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(2, 3)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 0.6580, -1.0969, -0.4614],
|
|||
|
|
[-0.1034, -0.5790, 0.1497]])
|
|||
|
|
>>> torch.cat((x, x, x), 0)
|
|||
|
|
tensor([[ 0.6580, -1.0969, -0.4614],
|
|||
|
|
[-0.1034, -0.5790, 0.1497],
|
|||
|
|
[ 0.6580, -1.0969, -0.4614],
|
|||
|
|
[-0.1034, -0.5790, 0.1497],
|
|||
|
|
[ 0.6580, -1.0969, -0.4614],
|
|||
|
|
[-0.1034, -0.5790, 0.1497]])
|
|||
|
|
>>> torch.cat((x, x, x), 1)
|
|||
|
|
tensor([[ 0.6580, -1.0969, -0.4614, 0.6580, -1.0969, -0.4614, 0.6580,
|
|||
|
|
-1.0969, -0.4614],
|
|||
|
|
[-0.1034, -0.5790, 0.1497, -0.1034, -0.5790, 0.1497, -0.1034,
|
|||
|
|
-0.5790, 0.1497]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def cat(tensors: Union[Tuple[Tensor, ...], List[Tensor]], dim: Union[str, ellipsis, None], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
cat(tensors, dim=0, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Concatenates the given sequence of :attr:`seq` tensors in the given dimension.
|
|||
|
|
All tensors must either have the same shape (except in the concatenating
|
|||
|
|
dimension) or be a 1-D empty tensor with size ``(0,)``.
|
|||
|
|
|
|||
|
|
:func:`torch.cat` can be seen as an inverse operation for :func:`torch.split`
|
|||
|
|
and :func:`torch.chunk`.
|
|||
|
|
|
|||
|
|
:func:`torch.cat` can be best understood via examples.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.stack` concatenates the given sequence along a new dimension.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
tensors (sequence of Tensors): any python sequence of tensors of the same type.
|
|||
|
|
Non-empty tensors provided must have the same shape, except in the
|
|||
|
|
cat dimension.
|
|||
|
|
dim (int, optional): the dimension over which the tensors are concatenated
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(2, 3)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 0.6580, -1.0969, -0.4614],
|
|||
|
|
[-0.1034, -0.5790, 0.1497]])
|
|||
|
|
>>> torch.cat((x, x, x), 0)
|
|||
|
|
tensor([[ 0.6580, -1.0969, -0.4614],
|
|||
|
|
[-0.1034, -0.5790, 0.1497],
|
|||
|
|
[ 0.6580, -1.0969, -0.4614],
|
|||
|
|
[-0.1034, -0.5790, 0.1497],
|
|||
|
|
[ 0.6580, -1.0969, -0.4614],
|
|||
|
|
[-0.1034, -0.5790, 0.1497]])
|
|||
|
|
>>> torch.cat((x, x, x), 1)
|
|||
|
|
tensor([[ 0.6580, -1.0969, -0.4614, 0.6580, -1.0969, -0.4614, 0.6580,
|
|||
|
|
-1.0969, -0.4614],
|
|||
|
|
[-0.1034, -0.5790, 0.1497, -0.1034, -0.5790, 0.1497, -0.1034,
|
|||
|
|
-0.5790, 0.1497]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def ccol_indices_copy(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def ceil(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
ceil(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the ceil of the elements of :attr:`input`,
|
|||
|
|
the smallest integer greater than or equal to each element.
|
|||
|
|
|
|||
|
|
For integer inputs, follows the array-api convention of returning a
|
|||
|
|
copy of the input tensor.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \left\lceil \text{input}_{i} \right\rceil
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([-0.6341, -1.4208, -1.0900, 0.5826])
|
|||
|
|
>>> torch.ceil(a)
|
|||
|
|
tensor([-0., -1., -1., 1.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def ceil_(input: Tensor) -> Tensor: ...
|
|||
|
|
def celu(input: Tensor, alpha: Union[Number, _complex] = 1.0) -> Tensor: ...
|
|||
|
|
def celu_(input: Tensor, alpha: Union[Number, _complex] = 1.0) -> Tensor: ...
|
|||
|
|
def channel_shuffle(input: Tensor, groups: Union[_int, SymInt]) -> Tensor: ...
|
|||
|
|
def cholesky(input: Tensor, upper: _bool = False, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
cholesky(input, upper=False, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the Cholesky decomposition of a symmetric positive-definite
|
|||
|
|
matrix :math:`A` or for batches of symmetric positive-definite matrices.
|
|||
|
|
|
|||
|
|
If :attr:`upper` is ``True``, the returned matrix ``U`` is upper-triangular, and
|
|||
|
|
the decomposition has the form:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
|
|||
|
|
A = U^TU
|
|||
|
|
|
|||
|
|
If :attr:`upper` is ``False``, the returned matrix ``L`` is lower-triangular, and
|
|||
|
|
the decomposition has the form:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
|
|||
|
|
A = LL^T
|
|||
|
|
|
|||
|
|
If :attr:`upper` is ``True``, and :math:`A` is a batch of symmetric positive-definite
|
|||
|
|
matrices, then the returned tensor will be composed of upper-triangular Cholesky factors
|
|||
|
|
of each of the individual matrices. Similarly, when :attr:`upper` is ``False``, the returned
|
|||
|
|
tensor will be composed of lower-triangular Cholesky factors of each of the individual
|
|||
|
|
matrices.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
|
|||
|
|
:func:`torch.cholesky` is deprecated in favor of :func:`torch.linalg.cholesky`
|
|||
|
|
and will be removed in a future PyTorch release.
|
|||
|
|
|
|||
|
|
``L = torch.cholesky(A)`` should be replaced with
|
|||
|
|
|
|||
|
|
.. code:: python
|
|||
|
|
|
|||
|
|
L = torch.linalg.cholesky(A)
|
|||
|
|
|
|||
|
|
``U = torch.cholesky(A, upper=True)`` should be replaced with
|
|||
|
|
|
|||
|
|
.. code:: python
|
|||
|
|
|
|||
|
|
U = torch.linalg.cholesky(A).mH
|
|||
|
|
|
|||
|
|
This transform will produce equivalent results for all valid (symmetric positive definite) inputs.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor :math:`A` of size :math:`(*, n, n)` where `*` is zero or more
|
|||
|
|
batch dimensions consisting of symmetric positive-definite matrices.
|
|||
|
|
upper (bool, optional): flag that indicates whether to return a
|
|||
|
|
upper or lower triangular matrix. Default: ``False``
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output matrix
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(3, 3)
|
|||
|
|
>>> a = a @ a.mT + 1e-3 # make symmetric positive-definite
|
|||
|
|
>>> l = torch.cholesky(a)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 2.4112, -0.7486, 1.4551],
|
|||
|
|
[-0.7486, 1.3544, 0.1294],
|
|||
|
|
[ 1.4551, 0.1294, 1.6724]])
|
|||
|
|
>>> l
|
|||
|
|
tensor([[ 1.5528, 0.0000, 0.0000],
|
|||
|
|
[-0.4821, 1.0592, 0.0000],
|
|||
|
|
[ 0.9371, 0.5487, 0.7023]])
|
|||
|
|
>>> l @ l.mT
|
|||
|
|
tensor([[ 2.4112, -0.7486, 1.4551],
|
|||
|
|
[-0.7486, 1.3544, 0.1294],
|
|||
|
|
[ 1.4551, 0.1294, 1.6724]])
|
|||
|
|
>>> a = torch.randn(3, 2, 2) # Example for batched input
|
|||
|
|
>>> a = a @ a.mT + 1e-03 # make symmetric positive-definite
|
|||
|
|
>>> l = torch.cholesky(a)
|
|||
|
|
>>> z = l @ l.mT
|
|||
|
|
>>> torch.dist(z, a)
|
|||
|
|
tensor(2.3842e-07)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def cholesky_inverse(input: Tensor, upper: _bool = False, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
cholesky_inverse(L, upper=False, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the inverse of a complex Hermitian or real symmetric
|
|||
|
|
positive-definite matrix given its Cholesky decomposition.
|
|||
|
|
|
|||
|
|
Let :math:`A` be a complex Hermitian or real symmetric positive-definite matrix,
|
|||
|
|
and :math:`L` its Cholesky decomposition such that:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
|
|||
|
|
A = LL^{\text{H}}
|
|||
|
|
|
|||
|
|
where :math:`L^{\text{H}}` is the conjugate transpose when :math:`L` is complex,
|
|||
|
|
and the transpose when :math:`L` is real-valued.
|
|||
|
|
|
|||
|
|
Computes the inverse matrix :math:`A^{-1}`.
|
|||
|
|
|
|||
|
|
Supports input of float, double, cfloat and cdouble dtypes.
|
|||
|
|
Also supports batches of matrices, and if :math:`A` is a batch of matrices
|
|||
|
|
then the output has the same batch dimensions.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
L (Tensor): tensor of shape `(*, n, n)` where `*` is zero or more batch dimensions
|
|||
|
|
consisting of lower or upper triangular Cholesky decompositions of
|
|||
|
|
symmetric or Hermitian positive-definite matrices.
|
|||
|
|
upper (bool, optional): flag that indicates whether :math:`L` is lower triangular
|
|||
|
|
or upper triangular. Default: ``False``
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): output tensor. Ignored if `None`. Default: `None`.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> A = torch.randn(3, 3)
|
|||
|
|
>>> A = A @ A.T + torch.eye(3) * 1e-3 # Creates a symmetric positive-definite matrix
|
|||
|
|
>>> L = torch.linalg.cholesky(A) # Extract Cholesky decomposition
|
|||
|
|
>>> torch.cholesky_inverse(L)
|
|||
|
|
tensor([[ 1.9314, 1.2251, -0.0889],
|
|||
|
|
[ 1.2251, 2.4439, 0.2122],
|
|||
|
|
[-0.0889, 0.2122, 0.1412]])
|
|||
|
|
>>> A.inverse()
|
|||
|
|
tensor([[ 1.9314, 1.2251, -0.0889],
|
|||
|
|
[ 1.2251, 2.4439, 0.2122],
|
|||
|
|
[-0.0889, 0.2122, 0.1412]])
|
|||
|
|
|
|||
|
|
>>> A = torch.randn(3, 2, 2, dtype=torch.complex64)
|
|||
|
|
>>> A = A @ A.mH + torch.eye(2) * 1e-3 # Batch of Hermitian positive-definite matrices
|
|||
|
|
>>> L = torch.linalg.cholesky(A)
|
|||
|
|
>>> torch.dist(torch.inverse(A), torch.cholesky_inverse(L))
|
|||
|
|
tensor(5.6358e-7)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def cholesky_solve(input: Tensor, input2: Tensor, upper: _bool = False, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
cholesky_solve(B, L, upper=False, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the solution of a system of linear equations with complex Hermitian
|
|||
|
|
or real symmetric positive-definite lhs given its Cholesky decomposition.
|
|||
|
|
|
|||
|
|
Let :math:`A` be a complex Hermitian or real symmetric positive-definite matrix,
|
|||
|
|
and :math:`L` its Cholesky decomposition such that:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
|
|||
|
|
A = LL^{\text{H}}
|
|||
|
|
|
|||
|
|
where :math:`L^{\text{H}}` is the conjugate transpose when :math:`L` is complex,
|
|||
|
|
and the transpose when :math:`L` is real-valued.
|
|||
|
|
|
|||
|
|
Returns the solution :math:`X` of the following linear system:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
|
|||
|
|
AX = B
|
|||
|
|
|
|||
|
|
Supports inputs of float, double, cfloat and cdouble dtypes.
|
|||
|
|
Also supports batches of matrices, and if :math:`A` or :math:`B` is a batch of matrices
|
|||
|
|
then the output has the same batch dimensions.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
B (Tensor): right-hand side tensor of shape `(*, n, k)`
|
|||
|
|
where :math:`*` is zero or more batch dimensions
|
|||
|
|
L (Tensor): tensor of shape `(*, n, n)` where `*` is zero or more batch dimensions
|
|||
|
|
consisting of lower or upper triangular Cholesky decompositions of
|
|||
|
|
symmetric or Hermitian positive-definite matrices.
|
|||
|
|
upper (bool, optional): flag that indicates whether :math:`L` is lower triangular
|
|||
|
|
or upper triangular. Default: ``False``.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): output tensor. Ignored if `None`. Default: `None`.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> A = torch.randn(3, 3)
|
|||
|
|
>>> A = A @ A.T + torch.eye(3) * 1e-3 # Creates a symmetric positive-definite matrix
|
|||
|
|
>>> L = torch.linalg.cholesky(A) # Extract Cholesky decomposition
|
|||
|
|
>>> B = torch.randn(3, 2)
|
|||
|
|
>>> torch.cholesky_solve(B, L)
|
|||
|
|
tensor([[ -8.1625, 19.6097],
|
|||
|
|
[ -5.8398, 14.2387],
|
|||
|
|
[ -4.3771, 10.4173]])
|
|||
|
|
>>> A.inverse() @ B
|
|||
|
|
tensor([[ -8.1626, 19.6097],
|
|||
|
|
[ -5.8398, 14.2387],
|
|||
|
|
[ -4.3771, 10.4173]])
|
|||
|
|
|
|||
|
|
>>> A = torch.randn(3, 2, 2, dtype=torch.complex64)
|
|||
|
|
>>> A = A @ A.mH + torch.eye(2) * 1e-3 # Batch of Hermitian positive-definite matrices
|
|||
|
|
>>> L = torch.linalg.cholesky(A)
|
|||
|
|
>>> B = torch.randn(2, 1, dtype=torch.complex64)
|
|||
|
|
>>> X = torch.cholesky_solve(B, L)
|
|||
|
|
>>> torch.dist(X, A.inverse() @ B)
|
|||
|
|
tensor(1.6881e-5)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def choose_qparams_optimized(input: Tensor, numel: _int, n_bins: _int, ratio: _float, bit_width: _int) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def chunk(input: Tensor, chunks: _int, dim: _int = 0) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
chunk(input, chunks, dim=0) -> List of Tensors
|
|||
|
|
|
|||
|
|
Attempts to split a tensor into the specified number of chunks. Each chunk is a view of
|
|||
|
|
the input tensor.
|
|||
|
|
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
This function may return fewer than the specified number of chunks!
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.tensor_split` a function that always returns exactly the specified number of chunks
|
|||
|
|
|
|||
|
|
If the tensor size along the given dimension :attr:`dim` is divisible by :attr:`chunks`,
|
|||
|
|
all returned chunks will be the same size.
|
|||
|
|
If the tensor size along the given dimension :attr:`dim` is not divisible by :attr:`chunks`,
|
|||
|
|
all returned chunks will be the same size, except the last one.
|
|||
|
|
If such division is not possible, this function may return fewer
|
|||
|
|
than the specified number of chunks.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
input (Tensor): the tensor to split
|
|||
|
|
chunks (int): number of chunks to return
|
|||
|
|
dim (int): dimension along which to split the tensor
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
>>> torch.arange(11).chunk(6)
|
|||
|
|
(tensor([0, 1]),
|
|||
|
|
tensor([2, 3]),
|
|||
|
|
tensor([4, 5]),
|
|||
|
|
tensor([6, 7]),
|
|||
|
|
tensor([8, 9]),
|
|||
|
|
tensor([10]))
|
|||
|
|
>>> torch.arange(12).chunk(6)
|
|||
|
|
(tensor([0, 1]),
|
|||
|
|
tensor([2, 3]),
|
|||
|
|
tensor([4, 5]),
|
|||
|
|
tensor([6, 7]),
|
|||
|
|
tensor([8, 9]),
|
|||
|
|
tensor([10, 11]))
|
|||
|
|
>>> torch.arange(13).chunk(6)
|
|||
|
|
(tensor([0, 1, 2]),
|
|||
|
|
tensor([3, 4, 5]),
|
|||
|
|
tensor([6, 7, 8]),
|
|||
|
|
tensor([ 9, 10, 11]),
|
|||
|
|
tensor([12]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def clamp(input: Tensor, min: Optional[Tensor] = None, max: Optional[Tensor] = None, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
clamp(input, min=None, max=None, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Clamps all elements in :attr:`input` into the range `[` :attr:`min`, :attr:`max` `]`.
|
|||
|
|
Letting min_value and max_value be :attr:`min` and :attr:`max`, respectively, this returns:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
y_i = \min(\max(x_i, \text{min\_value}_i), \text{max\_value}_i)
|
|||
|
|
|
|||
|
|
If :attr:`min` is ``None``, there is no lower bound.
|
|||
|
|
Or, if :attr:`max` is ``None`` there is no upper bound.
|
|||
|
|
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If :attr:`min` is greater than :attr:`max` :func:`torch.clamp(..., min, max) <torch.clamp>`
|
|||
|
|
sets all elements in :attr:`input` to the value of :attr:`max`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
min (Number or Tensor, optional): lower-bound of the range to be clamped to
|
|||
|
|
max (Number or Tensor, optional): upper-bound of the range to be clamped to
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([-1.7120, 0.1734, -0.0478, -0.0922])
|
|||
|
|
>>> torch.clamp(a, min=-0.5, max=0.5)
|
|||
|
|
tensor([-0.5000, 0.1734, -0.0478, -0.0922])
|
|||
|
|
|
|||
|
|
>>> min = torch.linspace(-1, 1, steps=4)
|
|||
|
|
>>> torch.clamp(a, min=min)
|
|||
|
|
tensor([-1.0000, 0.1734, 0.3333, 1.0000])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def clamp(input: Tensor, min: Optional[Union[Number, _complex]] = None, max: Optional[Union[Number, _complex]] = None, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
clamp(input, min=None, max=None, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Clamps all elements in :attr:`input` into the range `[` :attr:`min`, :attr:`max` `]`.
|
|||
|
|
Letting min_value and max_value be :attr:`min` and :attr:`max`, respectively, this returns:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
y_i = \min(\max(x_i, \text{min\_value}_i), \text{max\_value}_i)
|
|||
|
|
|
|||
|
|
If :attr:`min` is ``None``, there is no lower bound.
|
|||
|
|
Or, if :attr:`max` is ``None`` there is no upper bound.
|
|||
|
|
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If :attr:`min` is greater than :attr:`max` :func:`torch.clamp(..., min, max) <torch.clamp>`
|
|||
|
|
sets all elements in :attr:`input` to the value of :attr:`max`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
min (Number or Tensor, optional): lower-bound of the range to be clamped to
|
|||
|
|
max (Number or Tensor, optional): upper-bound of the range to be clamped to
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([-1.7120, 0.1734, -0.0478, -0.0922])
|
|||
|
|
>>> torch.clamp(a, min=-0.5, max=0.5)
|
|||
|
|
tensor([-0.5000, 0.1734, -0.0478, -0.0922])
|
|||
|
|
|
|||
|
|
>>> min = torch.linspace(-1, 1, steps=4)
|
|||
|
|
>>> torch.clamp(a, min=min)
|
|||
|
|
tensor([-1.0000, 0.1734, 0.3333, 1.0000])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def clamp_(input: Tensor, min: Optional[Tensor] = None, max: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def clamp_(input: Tensor, min: Optional[Union[Number, _complex]] = None, max: Optional[Union[Number, _complex]] = None) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def clamp_max(input: Tensor, max: Tensor, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def clamp_max(input: Tensor, max: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def clamp_max_(input: Tensor, max: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def clamp_max_(input: Tensor, max: Union[Number, _complex]) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def clamp_min(input: Tensor, min: Tensor, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def clamp_min(input: Tensor, min: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def clamp_min_(input: Tensor, min: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def clamp_min_(input: Tensor, min: Union[Number, _complex]) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def clip(input: Tensor, min: Optional[Tensor] = None, max: Optional[Tensor] = None, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
clip(input, min=None, max=None, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.clamp`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def clip(input: Tensor, min: Optional[Union[Number, _complex]] = None, max: Optional[Union[Number, _complex]] = None, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
clip(input, min=None, max=None, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.clamp`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def clip_(input: Tensor, min: Optional[Tensor] = None, max: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def clip_(input: Tensor, min: Optional[Union[Number, _complex]] = None, max: Optional[Union[Number, _complex]] = None) -> Tensor: ...
|
|||
|
|
def clone(input: Tensor, *, memory_format: Optional[memory_format] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
clone(input, *, memory_format=torch.preserve_format) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a copy of :attr:`input`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
This function is differentiable, so gradients will flow back from the
|
|||
|
|
result of this operation to :attr:`input`. To create a tensor without an
|
|||
|
|
autograd relationship to :attr:`input` see :meth:`~Tensor.detach`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
memory_format (:class:`torch.memory_format`, optional): the desired memory format of
|
|||
|
|
returned tensor. Default: ``torch.preserve_format``.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def col_indices_copy(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.col_indices`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def column_stack(tensors: Union[Tuple[Tensor, ...], List[Tensor]], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
column_stack(tensors, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Creates a new tensor by horizontally stacking the tensors in :attr:`tensors`.
|
|||
|
|
|
|||
|
|
Equivalent to ``torch.hstack(tensors)``, except each zero or one dimensional tensor ``t``
|
|||
|
|
in :attr:`tensors` is first reshaped into a ``(t.numel(), 1)`` column before being stacked horizontally.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
tensors (sequence of Tensors): sequence of tensors to concatenate
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([1, 2, 3])
|
|||
|
|
>>> b = torch.tensor([4, 5, 6])
|
|||
|
|
>>> torch.column_stack((a, b))
|
|||
|
|
tensor([[1, 4],
|
|||
|
|
[2, 5],
|
|||
|
|
[3, 6]])
|
|||
|
|
>>> a = torch.arange(5)
|
|||
|
|
>>> b = torch.arange(10).reshape(5, 2)
|
|||
|
|
>>> torch.column_stack((a, b, b))
|
|||
|
|
tensor([[0, 0, 1, 0, 1],
|
|||
|
|
[1, 2, 3, 2, 3],
|
|||
|
|
[2, 4, 5, 4, 5],
|
|||
|
|
[3, 6, 7, 6, 7],
|
|||
|
|
[4, 8, 9, 8, 9]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def combinations(input: Tensor, r: _int = 2, with_replacement: _bool = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
combinations(input, r=2, with_replacement=False) -> seq
|
|||
|
|
|
|||
|
|
Compute combinations of length :math:`r` of the given tensor. The behavior is similar to
|
|||
|
|
python's `itertools.combinations` when `with_replacement` is set to `False`, and
|
|||
|
|
`itertools.combinations_with_replacement` when `with_replacement` is set to `True`.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
input (Tensor): 1D vector.
|
|||
|
|
r (int, optional): number of elements to combine
|
|||
|
|
with_replacement (bool, optional): whether to allow duplication in combination
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A tensor equivalent to converting all the input tensors into lists, do
|
|||
|
|
`itertools.combinations` or `itertools.combinations_with_replacement` on these
|
|||
|
|
lists, and finally convert the resulting list into tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = [1, 2, 3]
|
|||
|
|
>>> list(itertools.combinations(a, r=2))
|
|||
|
|
[(1, 2), (1, 3), (2, 3)]
|
|||
|
|
>>> list(itertools.combinations(a, r=3))
|
|||
|
|
[(1, 2, 3)]
|
|||
|
|
>>> list(itertools.combinations_with_replacement(a, r=2))
|
|||
|
|
[(1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (3, 3)]
|
|||
|
|
>>> tensor_a = torch.tensor(a)
|
|||
|
|
>>> torch.combinations(tensor_a)
|
|||
|
|
tensor([[1, 2],
|
|||
|
|
[1, 3],
|
|||
|
|
[2, 3]])
|
|||
|
|
>>> torch.combinations(tensor_a, r=3)
|
|||
|
|
tensor([[1, 2, 3]])
|
|||
|
|
>>> torch.combinations(tensor_a, with_replacement=True)
|
|||
|
|
tensor([[1, 1],
|
|||
|
|
[1, 2],
|
|||
|
|
[1, 3],
|
|||
|
|
[2, 2],
|
|||
|
|
[2, 3],
|
|||
|
|
[3, 3]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def complex(real: Tensor, imag: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
complex(real, imag, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Constructs a complex tensor with its real part equal to :attr:`real` and its
|
|||
|
|
imaginary part equal to :attr:`imag`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
real (Tensor): The real part of the complex tensor. Must be half, float or double.
|
|||
|
|
imag (Tensor): The imaginary part of the complex tensor. Must be same dtype
|
|||
|
|
as :attr:`real`.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor): If the inputs are ``torch.float32``, must be
|
|||
|
|
``torch.complex64``. If the inputs are ``torch.float64``, must be
|
|||
|
|
``torch.complex128``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> real = torch.tensor([1, 2], dtype=torch.float32)
|
|||
|
|
>>> imag = torch.tensor([3, 4], dtype=torch.float32)
|
|||
|
|
>>> z = torch.complex(real, imag)
|
|||
|
|
>>> z
|
|||
|
|
tensor([(1.+3.j), (2.+4.j)])
|
|||
|
|
>>> z.dtype
|
|||
|
|
torch.complex64
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def concat(tensors: Union[Tuple[Tensor, ...], List[Tensor]], dim: _int = 0, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
concat(tensors, dim=0, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias of :func:`torch.cat`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def concat(tensors: Union[Tuple[Tensor, ...], List[Tensor]], dim: Union[str, ellipsis, None], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
concat(tensors, dim=0, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias of :func:`torch.cat`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def concatenate(tensors: Union[Tuple[Tensor, ...], List[Tensor]], dim: _int = 0, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
concatenate(tensors, axis=0, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias of :func:`torch.cat`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def concatenate(tensors: Union[Tuple[Tensor, ...], List[Tensor]], dim: Union[str, ellipsis, None], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
concatenate(tensors, axis=0, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias of :func:`torch.cat`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def conj(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
conj(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a view of :attr:`input` with a flipped conjugate bit. If :attr:`input` has a non-complex dtype,
|
|||
|
|
this function just returns :attr:`input`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
:func:`torch.conj` performs a lazy conjugation, but the actual conjugated tensor can be materialized
|
|||
|
|
at any time using :func:`torch.resolve_conj`.
|
|||
|
|
|
|||
|
|
.. warning:: In the future, :func:`torch.conj` may return a non-writeable view for an :attr:`input` of
|
|||
|
|
non-complex dtype. It's recommended that programs not modify the tensor returned by :func:`torch.conj_physical`
|
|||
|
|
when :attr:`input` is of non-complex dtype to be compatible with this change.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.tensor([-1 + 1j, -2 + 2j, 3 - 3j])
|
|||
|
|
>>> x.is_conj()
|
|||
|
|
False
|
|||
|
|
>>> y = torch.conj(x)
|
|||
|
|
>>> y.is_conj()
|
|||
|
|
True
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def conj_physical(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
conj_physical(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the element-wise conjugate of the given :attr:`input` tensor.
|
|||
|
|
If :attr:`input` has a non-complex dtype, this function just returns :attr:`input`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
This performs the conjugate operation regardless of the fact conjugate bit is set or not.
|
|||
|
|
|
|||
|
|
.. warning:: In the future, :func:`torch.conj_physical` may return a non-writeable view for an :attr:`input` of
|
|||
|
|
non-complex dtype. It's recommended that programs not modify the tensor returned by :func:`torch.conj_physical`
|
|||
|
|
when :attr:`input` is of non-complex dtype to be compatible with this change.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = conj(\text{input}_{i})
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.conj_physical(torch.tensor([-1 + 1j, -2 + 2j, 3 - 3j]))
|
|||
|
|
tensor([-1 - 1j, -2 - 2j, 3 + 3j])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def conj_physical_(input: Tensor) -> Tensor: ...
|
|||
|
|
def constant_pad_nd(input: Tensor, pad: Sequence[Union[_int, SymInt]], value: Union[Number, _complex] = 0) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def conv1d(input: Tensor, weight: Tensor, bias: Optional[Tensor] = None, stride: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 1, padding: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 0, dilation: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 1, groups: Union[_int, SymInt] = 1) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def conv1d(input: Tensor, weight: Tensor, bias: Optional[Tensor] = None, stride: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 1, padding: str = "valid", dilation: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 1, groups: Union[_int, SymInt] = 1) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def conv2d(input: Tensor, weight: Tensor, bias: Optional[Tensor] = None, stride: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 1, padding: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 0, dilation: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 1, groups: Union[_int, SymInt] = 1) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def conv2d(input: Tensor, weight: Tensor, bias: Optional[Tensor] = None, stride: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 1, padding: str = "valid", dilation: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 1, groups: Union[_int, SymInt] = 1) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def conv3d(input: Tensor, weight: Tensor, bias: Optional[Tensor] = None, stride: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 1, padding: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 0, dilation: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 1, groups: Union[_int, SymInt] = 1) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def conv3d(input: Tensor, weight: Tensor, bias: Optional[Tensor] = None, stride: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 1, padding: str = "valid", dilation: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 1, groups: Union[_int, SymInt] = 1) -> Tensor: ...
|
|||
|
|
def conv_tbc(input: Tensor, weight: Tensor, bias: Tensor, pad: _int = 0) -> Tensor: ...
|
|||
|
|
def conv_transpose1d(input: Tensor, weight: Tensor, bias: Optional[Tensor] = None, stride: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 1, padding: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 0, output_padding: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 0, groups: Union[_int, SymInt] = 1, dilation: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 1) -> Tensor: ...
|
|||
|
|
def conv_transpose2d(input: Tensor, weight: Tensor, bias: Optional[Tensor] = None, stride: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 1, padding: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 0, output_padding: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 0, groups: Union[_int, SymInt] = 1, dilation: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 1) -> Tensor: ...
|
|||
|
|
def conv_transpose3d(input: Tensor, weight: Tensor, bias: Optional[Tensor] = None, stride: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 1, padding: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 0, output_padding: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 0, groups: Union[_int, SymInt] = 1, dilation: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]] = 1) -> Tensor: ...
|
|||
|
|
def convolution(input: Tensor, weight: Tensor, bias: Optional[Tensor], stride: Sequence[Union[_int, SymInt]], padding: Sequence[Union[_int, SymInt]], dilation: Sequence[Union[_int, SymInt]], transposed: _bool, output_padding: Sequence[Union[_int, SymInt]], groups: Union[_int, SymInt]) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def copysign(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
copysign(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Create a new floating-point tensor with the magnitude of :attr:`input` and the sign of :attr:`other`, elementwise.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \begin{cases}
|
|||
|
|
-|\text{input}_{i}| & \text{if } \text{other}_{i} \leq -0.0 \\
|
|||
|
|
|\text{input}_{i}| & \text{if } \text{other}_{i} \geq 0.0 \\
|
|||
|
|
\end{cases}
|
|||
|
|
|
|||
|
|
|
|||
|
|
Supports :ref:`broadcasting to a common shape <broadcasting-semantics>`,
|
|||
|
|
and integer and float inputs.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): magnitudes.
|
|||
|
|
other (Tensor or Number): contains value(s) whose signbit(s) are
|
|||
|
|
applied to the magnitudes in :attr:`input`.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(5)
|
|||
|
|
>>> a
|
|||
|
|
tensor([-1.2557, -0.0026, -0.5387, 0.4740, -0.9244])
|
|||
|
|
>>> torch.copysign(a, 1)
|
|||
|
|
tensor([1.2557, 0.0026, 0.5387, 0.4740, 0.9244])
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.7079, 0.2778, -1.0249, 0.5719],
|
|||
|
|
[-0.0059, -0.2600, -0.4475, -1.3948],
|
|||
|
|
[ 0.3667, -0.9567, -2.5757, -0.1751],
|
|||
|
|
[ 0.2046, -0.0742, 0.2998, -0.1054]])
|
|||
|
|
>>> b = torch.randn(4)
|
|||
|
|
tensor([ 0.2373, 0.3120, 0.3190, -1.1128])
|
|||
|
|
>>> torch.copysign(a, b)
|
|||
|
|
tensor([[ 0.7079, 0.2778, 1.0249, -0.5719],
|
|||
|
|
[ 0.0059, 0.2600, 0.4475, -1.3948],
|
|||
|
|
[ 0.3667, 0.9567, 2.5757, -0.1751],
|
|||
|
|
[ 0.2046, 0.0742, 0.2998, -0.1054]])
|
|||
|
|
>>> a = torch.tensor([1.])
|
|||
|
|
>>> b = torch.tensor([-0.])
|
|||
|
|
>>> torch.copysign(a, b)
|
|||
|
|
tensor([-1.])
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
copysign handles signed zeros. If the other argument has a negative zero (-0),
|
|||
|
|
the corresponding output value will be negative.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def copysign(input: Tensor, other: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
copysign(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Create a new floating-point tensor with the magnitude of :attr:`input` and the sign of :attr:`other`, elementwise.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \begin{cases}
|
|||
|
|
-|\text{input}_{i}| & \text{if } \text{other}_{i} \leq -0.0 \\
|
|||
|
|
|\text{input}_{i}| & \text{if } \text{other}_{i} \geq 0.0 \\
|
|||
|
|
\end{cases}
|
|||
|
|
|
|||
|
|
|
|||
|
|
Supports :ref:`broadcasting to a common shape <broadcasting-semantics>`,
|
|||
|
|
and integer and float inputs.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): magnitudes.
|
|||
|
|
other (Tensor or Number): contains value(s) whose signbit(s) are
|
|||
|
|
applied to the magnitudes in :attr:`input`.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(5)
|
|||
|
|
>>> a
|
|||
|
|
tensor([-1.2557, -0.0026, -0.5387, 0.4740, -0.9244])
|
|||
|
|
>>> torch.copysign(a, 1)
|
|||
|
|
tensor([1.2557, 0.0026, 0.5387, 0.4740, 0.9244])
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.7079, 0.2778, -1.0249, 0.5719],
|
|||
|
|
[-0.0059, -0.2600, -0.4475, -1.3948],
|
|||
|
|
[ 0.3667, -0.9567, -2.5757, -0.1751],
|
|||
|
|
[ 0.2046, -0.0742, 0.2998, -0.1054]])
|
|||
|
|
>>> b = torch.randn(4)
|
|||
|
|
tensor([ 0.2373, 0.3120, 0.3190, -1.1128])
|
|||
|
|
>>> torch.copysign(a, b)
|
|||
|
|
tensor([[ 0.7079, 0.2778, 1.0249, -0.5719],
|
|||
|
|
[ 0.0059, 0.2600, 0.4475, -1.3948],
|
|||
|
|
[ 0.3667, 0.9567, 2.5757, -0.1751],
|
|||
|
|
[ 0.2046, 0.0742, 0.2998, -0.1054]])
|
|||
|
|
>>> a = torch.tensor([1.])
|
|||
|
|
>>> b = torch.tensor([-0.])
|
|||
|
|
>>> torch.copysign(a, b)
|
|||
|
|
tensor([-1.])
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
copysign handles signed zeros. If the other argument has a negative zero (-0),
|
|||
|
|
the corresponding output value will be negative.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def corrcoef(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
corrcoef(input) -> Tensor
|
|||
|
|
|
|||
|
|
Estimates the Pearson product-moment correlation coefficient matrix of the variables given by the :attr:`input` matrix,
|
|||
|
|
where rows are the variables and columns are the observations.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
The correlation coefficient matrix R is computed using the covariance matrix C as given by
|
|||
|
|
:math:`R_{ij} = \frac{ C_{ij} } { \sqrt{ C_{ii} * C_{jj} } }`
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
Due to floating point rounding, the resulting array may not be Hermitian and its diagonal elements may not be 1.
|
|||
|
|
The real and imaginary values are clipped to the interval [-1, 1] in an attempt to improve this situation.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): A 2D matrix containing multiple variables and observations, or a
|
|||
|
|
Scalar or 1D vector representing a single variable.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
(Tensor) The correlation coefficient matrix of the variables.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.cov` covariance matrix.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.tensor([[0, 1, 2], [2, 1, 0]])
|
|||
|
|
>>> torch.corrcoef(x)
|
|||
|
|
tensor([[ 1., -1.],
|
|||
|
|
[-1., 1.]])
|
|||
|
|
>>> x = torch.randn(2, 4)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[-0.2678, -0.0908, -0.3766, 0.2780],
|
|||
|
|
[-0.5812, 0.1535, 0.2387, 0.2350]])
|
|||
|
|
>>> torch.corrcoef(x)
|
|||
|
|
tensor([[1.0000, 0.3582],
|
|||
|
|
[0.3582, 1.0000]])
|
|||
|
|
>>> torch.corrcoef(x[0])
|
|||
|
|
tensor(1.)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def cos(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
cos(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the cosine of the elements of :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \cos(\text{input}_{i})
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 1.4309, 1.2706, -0.8562, 0.9796])
|
|||
|
|
>>> torch.cos(a)
|
|||
|
|
tensor([ 0.1395, 0.2957, 0.6553, 0.5574])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def cos_(input: Tensor) -> Tensor: ...
|
|||
|
|
def cosh(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
cosh(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the hyperbolic cosine of the elements of
|
|||
|
|
:attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \cosh(\text{input}_{i})
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 0.1632, 1.1835, -0.6979, -0.7325])
|
|||
|
|
>>> torch.cosh(a)
|
|||
|
|
tensor([ 1.0133, 1.7860, 1.2536, 1.2805])
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
When :attr:`input` is on the CPU, the implementation of torch.cosh may use
|
|||
|
|
the Sleef library, which rounds very large results to infinity or negative
|
|||
|
|
infinity. See `here <https://sleef.org/purec.xhtml>`_ for details.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def cosh_(input: Tensor) -> Tensor: ...
|
|||
|
|
def cosine_embedding_loss(input1: Tensor, input2: Tensor, target: Tensor, margin: _float = 0.0, reduction: _int = 1) -> Tensor: ...
|
|||
|
|
def cosine_similarity(x1: Tensor, x2: Tensor, dim: _int = 1, eps: _float = 1e-08) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def count_nonzero(input: Tensor, dim: Optional[_int] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
count_nonzero(input, dim=None) -> Tensor
|
|||
|
|
|
|||
|
|
Counts the number of non-zero values in the tensor :attr:`input` along the given :attr:`dim`.
|
|||
|
|
If no dim is specified then all non-zeros in the tensor are counted.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints, optional): Dim or tuple of dims along which to count non-zeros.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.zeros(3,3)
|
|||
|
|
>>> x[torch.randn(3,3) > 0.5] = 1
|
|||
|
|
>>> x
|
|||
|
|
tensor([[0., 1., 1.],
|
|||
|
|
[0., 0., 0.],
|
|||
|
|
[0., 0., 1.]])
|
|||
|
|
>>> torch.count_nonzero(x)
|
|||
|
|
tensor(3)
|
|||
|
|
>>> torch.count_nonzero(x, dim=0)
|
|||
|
|
tensor([0, 1, 2])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def count_nonzero(input: Tensor, dim: _size) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
count_nonzero(input, dim=None) -> Tensor
|
|||
|
|
|
|||
|
|
Counts the number of non-zero values in the tensor :attr:`input` along the given :attr:`dim`.
|
|||
|
|
If no dim is specified then all non-zeros in the tensor are counted.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints, optional): Dim or tuple of dims along which to count non-zeros.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.zeros(3,3)
|
|||
|
|
>>> x[torch.randn(3,3) > 0.5] = 1
|
|||
|
|
>>> x
|
|||
|
|
tensor([[0., 1., 1.],
|
|||
|
|
[0., 0., 0.],
|
|||
|
|
[0., 0., 1.]])
|
|||
|
|
>>> torch.count_nonzero(x)
|
|||
|
|
tensor(3)
|
|||
|
|
>>> torch.count_nonzero(x, dim=0)
|
|||
|
|
tensor([0, 1, 2])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def cov(input: Tensor, *, correction: _int = 1, fweights: Optional[Tensor] = None, aweights: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
cov(input, *, correction=1, fweights=None, aweights=None) -> Tensor
|
|||
|
|
|
|||
|
|
Estimates the covariance matrix of the variables given by the :attr:`input` matrix, where rows are
|
|||
|
|
the variables and columns are the observations.
|
|||
|
|
|
|||
|
|
A covariance matrix is a square matrix giving the covariance of each pair of variables. The diagonal contains
|
|||
|
|
the variance of each variable (covariance of a variable with itself). By definition, if :attr:`input` represents
|
|||
|
|
a single variable (Scalar or 1D) then its variance is returned.
|
|||
|
|
|
|||
|
|
The sample covariance of the variables :math:`x` and :math:`y` is given by:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{cov}(x,y) = \frac{\sum^{N}_{i = 1}(x_{i} - \bar{x})(y_{i} - \bar{y})}{\max(0,~N~-~\delta N)}
|
|||
|
|
|
|||
|
|
where :math:`\bar{x}` and :math:`\bar{y}` are the simple means of the :math:`x` and :math:`y` respectively, and
|
|||
|
|
:math:`\delta N` is the :attr:`correction`.
|
|||
|
|
|
|||
|
|
If :attr:`fweights` and/or :attr:`aweights` are provided, the weighted covariance
|
|||
|
|
is calculated, which is given by:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{cov}_w(x,y) = \frac{\sum^{N}_{i = 1}w_i(x_{i} - \mu_x^*)(y_{i} - \mu_y^*)}
|
|||
|
|
{\max(0,~\sum^{N}_{i = 1}w_i~-~\frac{\sum^{N}_{i = 1}w_ia_i}{\sum^{N}_{i = 1}w_i}~\delta N)}
|
|||
|
|
|
|||
|
|
where :math:`w` denotes :attr:`fweights` or :attr:`aweights` (``f`` and ``a`` for brevity) based on whichever is
|
|||
|
|
provided, or :math:`w = f \times a` if both are provided, and
|
|||
|
|
:math:`\mu_x^* = \frac{\sum^{N}_{i = 1}w_ix_{i} }{\sum^{N}_{i = 1}w_i}` is the weighted mean of the variable. If not
|
|||
|
|
provided, ``f`` and/or ``a`` can be seen as a :math:`\mathbb{1}` vector of appropriate size.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): A 2D matrix containing multiple variables and observations, or a
|
|||
|
|
Scalar or 1D vector representing a single variable.
|
|||
|
|
|
|||
|
|
Keyword Args:
|
|||
|
|
correction (int, optional): difference between the sample size and sample degrees of freedom.
|
|||
|
|
Defaults to Bessel's correction, ``correction = 1`` which returns the unbiased estimate,
|
|||
|
|
even if both :attr:`fweights` and :attr:`aweights` are specified. ``correction = 0``
|
|||
|
|
will return the simple average. Defaults to ``1``.
|
|||
|
|
fweights (tensor, optional): A Scalar or 1D tensor of observation vector frequencies representing the number of
|
|||
|
|
times each observation should be repeated. Its numel must equal the number of columns of :attr:`input`.
|
|||
|
|
Must have integral dtype. Ignored if ``None``. Defaults to ``None``.
|
|||
|
|
aweights (tensor, optional): A Scalar or 1D array of observation vector weights.
|
|||
|
|
These relative weights are typically large for observations considered <EFBFBD>important<EFBFBD> and smaller for
|
|||
|
|
observations considered less <EFBFBD>important<EFBFBD>. Its numel must equal the number of columns of :attr:`input`.
|
|||
|
|
Must have floating point dtype. Ignored if ``None``. Defaults to ``None``.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
(Tensor) The covariance matrix of the variables.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.corrcoef` normalized covariance matrix.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
>>> x = torch.tensor([[0, 2], [1, 1], [2, 0]]).T
|
|||
|
|
>>> x
|
|||
|
|
tensor([[0, 1, 2],
|
|||
|
|
[2, 1, 0]])
|
|||
|
|
>>> torch.cov(x)
|
|||
|
|
tensor([[ 1., -1.],
|
|||
|
|
[-1., 1.]])
|
|||
|
|
>>> torch.cov(x, correction=0)
|
|||
|
|
tensor([[ 0.6667, -0.6667],
|
|||
|
|
[-0.6667, 0.6667]])
|
|||
|
|
>>> fw = torch.randint(1, 10, (3,))
|
|||
|
|
>>> fw
|
|||
|
|
tensor([1, 6, 9])
|
|||
|
|
>>> aw = torch.rand(3)
|
|||
|
|
>>> aw
|
|||
|
|
tensor([0.4282, 0.0255, 0.4144])
|
|||
|
|
>>> torch.cov(x, fweights=fw, aweights=aw)
|
|||
|
|
tensor([[ 0.4169, -0.4169],
|
|||
|
|
[-0.4169, 0.4169]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def cross(input: Tensor, other: Tensor, dim: Optional[_int] = None, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
cross(input, other, dim=None, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
|
|||
|
|
Returns the cross product of vectors in dimension :attr:`dim` of :attr:`input`
|
|||
|
|
and :attr:`other`.
|
|||
|
|
|
|||
|
|
Supports input of float, double, cfloat and cdouble dtypes. Also supports batches
|
|||
|
|
of vectors, for which it computes the product along the dimension :attr:`dim`.
|
|||
|
|
In this case, the output has the same batch dimensions as the inputs.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
If :attr:`dim` is not given, it defaults to the first dimension found
|
|||
|
|
with the size 3. Note that this might be unexpected.
|
|||
|
|
|
|||
|
|
This behavior is deprecated and will be changed to match that of :func:`torch.linalg.cross`
|
|||
|
|
in a future release.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
:func:`torch.linalg.cross` which has dim=-1 as default.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
other (Tensor): the second input tensor
|
|||
|
|
dim (int, optional): the dimension to take the cross-product in.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[-0.3956, 1.1455, 1.6895],
|
|||
|
|
[-0.5849, 1.3672, 0.3599],
|
|||
|
|
[-1.1626, 0.7180, -0.0521],
|
|||
|
|
[-0.1339, 0.9902, -2.0225]])
|
|||
|
|
>>> b = torch.randn(4, 3)
|
|||
|
|
>>> b
|
|||
|
|
tensor([[-0.0257, -1.4725, -1.2251],
|
|||
|
|
[-1.1479, -0.7005, -1.9757],
|
|||
|
|
[-1.3904, 0.3726, -1.1836],
|
|||
|
|
[-0.9688, -0.7153, 0.2159]])
|
|||
|
|
>>> torch.cross(a, b, dim=1)
|
|||
|
|
tensor([[ 1.0844, -0.5281, 0.6120],
|
|||
|
|
[-2.4490, -1.5687, 1.9792],
|
|||
|
|
[-0.8304, -1.3037, 0.5650],
|
|||
|
|
[-1.2329, 1.9883, 1.0551]])
|
|||
|
|
>>> torch.cross(a, b)
|
|||
|
|
tensor([[ 1.0844, -0.5281, 0.6120],
|
|||
|
|
[-2.4490, -1.5687, 1.9792],
|
|||
|
|
[-0.8304, -1.3037, 0.5650],
|
|||
|
|
[-1.2329, 1.9883, 1.0551]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def crow_indices_copy(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.crow_indices`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def ctc_loss(log_probs: Tensor, targets: Tensor, input_lengths: _size, target_lengths: _size, blank: _int = 0, reduction: _int = 1, zero_infinity: _bool = False) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def ctc_loss(log_probs: Tensor, targets: Tensor, input_lengths: Tensor, target_lengths: Tensor, blank: _int = 0, reduction: _int = 1, zero_infinity: _bool = False) -> Tensor: ...
|
|||
|
|
def cudnn_affine_grid_generator(theta: Tensor, N: _int, C: _int, H: _int, W: _int) -> Tensor: ...
|
|||
|
|
def cudnn_batch_norm(input: Tensor, weight: Tensor, bias: Optional[Tensor], running_mean: Optional[Tensor], running_var: Optional[Tensor], training: _bool, exponential_average_factor: _float, epsilon: _float) -> Tuple[Tensor, Tensor, Tensor, Tensor]: ...
|
|||
|
|
def cudnn_convolution(input: Tensor, weight: Tensor, padding: Sequence[Union[_int, SymInt]], stride: Sequence[Union[_int, SymInt]], dilation: Sequence[Union[_int, SymInt]], groups: Union[_int, SymInt], benchmark: _bool, deterministic: _bool, allow_tf32: _bool, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def cudnn_convolution_add_relu(input: Tensor, weight: Tensor, z: Tensor, alpha: Optional[Union[Number, _complex]], bias: Optional[Tensor], stride: Sequence[Union[_int, SymInt]], padding: Sequence[Union[_int, SymInt]], dilation: Sequence[Union[_int, SymInt]], groups: Union[_int, SymInt]) -> Tensor: ...
|
|||
|
|
def cudnn_convolution_relu(input: Tensor, weight: Tensor, bias: Optional[Tensor], stride: Sequence[Union[_int, SymInt]], padding: Sequence[Union[_int, SymInt]], dilation: Sequence[Union[_int, SymInt]], groups: Union[_int, SymInt]) -> Tensor: ...
|
|||
|
|
def cudnn_convolution_transpose(input: Tensor, weight: Tensor, padding: Sequence[Union[_int, SymInt]], output_padding: Sequence[Union[_int, SymInt]], stride: Sequence[Union[_int, SymInt]], dilation: Sequence[Union[_int, SymInt]], groups: Union[_int, SymInt], benchmark: _bool, deterministic: _bool, allow_tf32: _bool) -> Tensor: ...
|
|||
|
|
def cudnn_grid_sampler(input: Tensor, grid: Tensor) -> Tensor: ...
|
|||
|
|
def cudnn_is_acceptable(input: Tensor) -> _bool: ...
|
|||
|
|
@overload
|
|||
|
|
def cummax(input: Tensor, dim: _int, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.cummax:
|
|||
|
|
r"""
|
|||
|
|
cummax(input, dim, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
Returns a namedtuple ``(values, indices)`` where ``values`` is the cumulative maximum of
|
|||
|
|
elements of :attr:`input` in the dimension :attr:`dim`. And ``indices`` is the index
|
|||
|
|
location of each maximum value found in the dimension :attr:`dim`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
y_i = max(x_1, x_2, x_3, \dots, x_i)
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to do the operation over
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the result tuple of two output tensors (values, indices)
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(10)
|
|||
|
|
>>> a
|
|||
|
|
tensor([-0.3449, -1.5447, 0.0685, -1.5104, -1.1706, 0.2259, 1.4696, -1.3284,
|
|||
|
|
1.9946, -0.8209])
|
|||
|
|
>>> torch.cummax(a, dim=0)
|
|||
|
|
torch.return_types.cummax(
|
|||
|
|
values=tensor([-0.3449, -0.3449, 0.0685, 0.0685, 0.0685, 0.2259, 1.4696, 1.4696,
|
|||
|
|
1.9946, 1.9946]),
|
|||
|
|
indices=tensor([0, 0, 2, 2, 2, 5, 6, 6, 8, 8]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def cummax(input: Tensor, dim: Union[str, ellipsis, None], *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.cummax:
|
|||
|
|
r"""
|
|||
|
|
cummax(input, dim, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
Returns a namedtuple ``(values, indices)`` where ``values`` is the cumulative maximum of
|
|||
|
|
elements of :attr:`input` in the dimension :attr:`dim`. And ``indices`` is the index
|
|||
|
|
location of each maximum value found in the dimension :attr:`dim`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
y_i = max(x_1, x_2, x_3, \dots, x_i)
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to do the operation over
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the result tuple of two output tensors (values, indices)
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(10)
|
|||
|
|
>>> a
|
|||
|
|
tensor([-0.3449, -1.5447, 0.0685, -1.5104, -1.1706, 0.2259, 1.4696, -1.3284,
|
|||
|
|
1.9946, -0.8209])
|
|||
|
|
>>> torch.cummax(a, dim=0)
|
|||
|
|
torch.return_types.cummax(
|
|||
|
|
values=tensor([-0.3449, -0.3449, 0.0685, 0.0685, 0.0685, 0.2259, 1.4696, 1.4696,
|
|||
|
|
1.9946, 1.9946]),
|
|||
|
|
indices=tensor([0, 0, 2, 2, 2, 5, 6, 6, 8, 8]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def cummin(input: Tensor, dim: _int, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.cummin:
|
|||
|
|
r"""
|
|||
|
|
cummin(input, dim, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
Returns a namedtuple ``(values, indices)`` where ``values`` is the cumulative minimum of
|
|||
|
|
elements of :attr:`input` in the dimension :attr:`dim`. And ``indices`` is the index
|
|||
|
|
location of each maximum value found in the dimension :attr:`dim`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
y_i = min(x_1, x_2, x_3, \dots, x_i)
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to do the operation over
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the result tuple of two output tensors (values, indices)
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(10)
|
|||
|
|
>>> a
|
|||
|
|
tensor([-0.2284, -0.6628, 0.0975, 0.2680, -1.3298, -0.4220, -0.3885, 1.1762,
|
|||
|
|
0.9165, 1.6684])
|
|||
|
|
>>> torch.cummin(a, dim=0)
|
|||
|
|
torch.return_types.cummin(
|
|||
|
|
values=tensor([-0.2284, -0.6628, -0.6628, -0.6628, -1.3298, -1.3298, -1.3298, -1.3298,
|
|||
|
|
-1.3298, -1.3298]),
|
|||
|
|
indices=tensor([0, 1, 1, 1, 4, 4, 4, 4, 4, 4]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def cummin(input: Tensor, dim: Union[str, ellipsis, None], *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.cummin:
|
|||
|
|
r"""
|
|||
|
|
cummin(input, dim, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
Returns a namedtuple ``(values, indices)`` where ``values`` is the cumulative minimum of
|
|||
|
|
elements of :attr:`input` in the dimension :attr:`dim`. And ``indices`` is the index
|
|||
|
|
location of each maximum value found in the dimension :attr:`dim`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
y_i = min(x_1, x_2, x_3, \dots, x_i)
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to do the operation over
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the result tuple of two output tensors (values, indices)
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(10)
|
|||
|
|
>>> a
|
|||
|
|
tensor([-0.2284, -0.6628, 0.0975, 0.2680, -1.3298, -0.4220, -0.3885, 1.1762,
|
|||
|
|
0.9165, 1.6684])
|
|||
|
|
>>> torch.cummin(a, dim=0)
|
|||
|
|
torch.return_types.cummin(
|
|||
|
|
values=tensor([-0.2284, -0.6628, -0.6628, -0.6628, -1.3298, -1.3298, -1.3298, -1.3298,
|
|||
|
|
-1.3298, -1.3298]),
|
|||
|
|
indices=tensor([0, 1, 1, 1, 4, 4, 4, 4, 4, 4]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def cumprod(input: Tensor, dim: _int, *, dtype: Optional[_dtype] = None, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
cumprod(input, dim, *, dtype=None, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the cumulative product of elements of :attr:`input` in the dimension
|
|||
|
|
:attr:`dim`.
|
|||
|
|
|
|||
|
|
For example, if :attr:`input` is a vector of size N, the result will also be
|
|||
|
|
a vector of size N, with elements.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
y_i = x_1 \times x_2\times x_3\times \dots \times x_i
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to do the operation over
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(10)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 0.6001, 0.2069, -0.1919, 0.9792, 0.6727, 1.0062, 0.4126,
|
|||
|
|
-0.2129, -0.4206, 0.1968])
|
|||
|
|
>>> torch.cumprod(a, dim=0)
|
|||
|
|
tensor([ 0.6001, 0.1241, -0.0238, -0.0233, -0.0157, -0.0158, -0.0065,
|
|||
|
|
0.0014, -0.0006, -0.0001])
|
|||
|
|
|
|||
|
|
>>> a[5] = 0.0
|
|||
|
|
>>> torch.cumprod(a, dim=0)
|
|||
|
|
tensor([ 0.6001, 0.1241, -0.0238, -0.0233, -0.0157, -0.0000, -0.0000,
|
|||
|
|
0.0000, -0.0000, -0.0000])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def cumprod(input: Tensor, dim: Union[str, ellipsis, None], *, dtype: Optional[_dtype] = None, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
cumprod(input, dim, *, dtype=None, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the cumulative product of elements of :attr:`input` in the dimension
|
|||
|
|
:attr:`dim`.
|
|||
|
|
|
|||
|
|
For example, if :attr:`input` is a vector of size N, the result will also be
|
|||
|
|
a vector of size N, with elements.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
y_i = x_1 \times x_2\times x_3\times \dots \times x_i
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to do the operation over
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(10)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 0.6001, 0.2069, -0.1919, 0.9792, 0.6727, 1.0062, 0.4126,
|
|||
|
|
-0.2129, -0.4206, 0.1968])
|
|||
|
|
>>> torch.cumprod(a, dim=0)
|
|||
|
|
tensor([ 0.6001, 0.1241, -0.0238, -0.0233, -0.0157, -0.0158, -0.0065,
|
|||
|
|
0.0014, -0.0006, -0.0001])
|
|||
|
|
|
|||
|
|
>>> a[5] = 0.0
|
|||
|
|
>>> torch.cumprod(a, dim=0)
|
|||
|
|
tensor([ 0.6001, 0.1241, -0.0238, -0.0233, -0.0157, -0.0000, -0.0000,
|
|||
|
|
0.0000, -0.0000, -0.0000])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def cumsum(input: Tensor, dim: _int, *, dtype: Optional[_dtype] = None, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
cumsum(input, dim, *, dtype=None, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the cumulative sum of elements of :attr:`input` in the dimension
|
|||
|
|
:attr:`dim`.
|
|||
|
|
|
|||
|
|
For example, if :attr:`input` is a vector of size N, the result will also be
|
|||
|
|
a vector of size N, with elements.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
y_i = x_1 + x_2 + x_3 + \dots + x_i
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to do the operation over
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randint(1, 20, (10,))
|
|||
|
|
>>> a
|
|||
|
|
tensor([13, 7, 3, 10, 13, 3, 15, 10, 9, 10])
|
|||
|
|
>>> torch.cumsum(a, dim=0)
|
|||
|
|
tensor([13, 20, 23, 33, 46, 49, 64, 74, 83, 93])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def cumsum(input: Tensor, dim: Union[str, ellipsis, None], *, dtype: Optional[_dtype] = None, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
cumsum(input, dim, *, dtype=None, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the cumulative sum of elements of :attr:`input` in the dimension
|
|||
|
|
:attr:`dim`.
|
|||
|
|
|
|||
|
|
For example, if :attr:`input` is a vector of size N, the result will also be
|
|||
|
|
a vector of size N, with elements.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
y_i = x_1 + x_2 + x_3 + \dots + x_i
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to do the operation over
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randint(1, 20, (10,))
|
|||
|
|
>>> a
|
|||
|
|
tensor([13, 7, 3, 10, 13, 3, 15, 10, 9, 10])
|
|||
|
|
>>> torch.cumsum(a, dim=0)
|
|||
|
|
tensor([13, 20, 23, 33, 46, 49, 64, 74, 83, 93])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def cumulative_trapezoid(y: Tensor, x: Tensor, *, dim: _int = -1) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
cumulative_trapezoid(y, x=None, *, dx=None, dim=-1) -> Tensor
|
|||
|
|
|
|||
|
|
Cumulatively computes the `trapezoidal rule <https://en.wikipedia.org/wiki/Trapezoidal_rule>`_
|
|||
|
|
along :attr:`dim`. By default the spacing between elements is assumed to be 1, but
|
|||
|
|
:attr:`dx` can be used to specify a different constant spacing, and :attr:`x` can be
|
|||
|
|
used to specify arbitrary spacing along :attr:`dim`.
|
|||
|
|
|
|||
|
|
For more details, please read :func:`torch.trapezoid`. The difference between :func:`torch.trapezoid`
|
|||
|
|
and this function is that, :func:`torch.trapezoid` returns a value for each integration,
|
|||
|
|
where as this function returns a cumulative value for every spacing within the integration. This
|
|||
|
|
is analogous to how `.sum` returns a value and `.cumsum` returns a cumulative sum.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
y (Tensor): Values to use when computing the trapezoidal rule.
|
|||
|
|
x (Tensor): If specified, defines spacing between values as specified above.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
dx (float): constant spacing between values. If neither :attr:`x` or :attr:`dx`
|
|||
|
|
are specified then this defaults to 1. Effectively multiplies the result by its value.
|
|||
|
|
dim (int): The dimension along which to compute the trapezoidal rule.
|
|||
|
|
The last (inner-most) dimension by default.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> # Cumulatively computes the trapezoidal rule in 1D, spacing is implicitly 1.
|
|||
|
|
>>> y = torch.tensor([1, 5, 10])
|
|||
|
|
>>> torch.cumulative_trapezoid(y)
|
|||
|
|
tensor([3., 10.5])
|
|||
|
|
|
|||
|
|
>>> # Computes the same trapezoidal rule directly up to each element to verify
|
|||
|
|
>>> (1 + 5) / 2
|
|||
|
|
3.0
|
|||
|
|
>>> (1 + 10 + 10) / 2
|
|||
|
|
10.5
|
|||
|
|
|
|||
|
|
>>> # Cumulatively computes the trapezoidal rule in 1D with constant spacing of 2
|
|||
|
|
>>> # NOTE: the result is the same as before, but multiplied by 2
|
|||
|
|
>>> torch.cumulative_trapezoid(y, dx=2)
|
|||
|
|
tensor([6., 21.])
|
|||
|
|
|
|||
|
|
>>> # Cumulatively computes the trapezoidal rule in 1D with arbitrary spacing
|
|||
|
|
>>> x = torch.tensor([1, 3, 6])
|
|||
|
|
>>> torch.cumulative_trapezoid(y, x)
|
|||
|
|
tensor([6., 28.5])
|
|||
|
|
|
|||
|
|
>>> # Computes the same trapezoidal rule directly up to each element to verify
|
|||
|
|
>>> ((3 - 1) * (1 + 5)) / 2
|
|||
|
|
6.0
|
|||
|
|
>>> ((3 - 1) * (1 + 5) + (6 - 3) * (5 + 10)) / 2
|
|||
|
|
28.5
|
|||
|
|
|
|||
|
|
>>> # Cumulatively computes the trapezoidal rule for each row of a 3x3 matrix
|
|||
|
|
>>> y = torch.arange(9).reshape(3, 3)
|
|||
|
|
tensor([[0, 1, 2],
|
|||
|
|
[3, 4, 5],
|
|||
|
|
[6, 7, 8]])
|
|||
|
|
>>> torch.cumulative_trapezoid(y)
|
|||
|
|
tensor([[ 0.5, 2.],
|
|||
|
|
[ 3.5, 8.],
|
|||
|
|
[ 6.5, 14.]])
|
|||
|
|
|
|||
|
|
>>> # Cumulatively computes the trapezoidal rule for each column of the matrix
|
|||
|
|
>>> torch.cumulative_trapezoid(y, dim=0)
|
|||
|
|
tensor([[ 1.5, 2.5, 3.5],
|
|||
|
|
[ 6.0, 8.0, 10.0]])
|
|||
|
|
|
|||
|
|
>>> # Cumulatively computes the trapezoidal rule for each row of a 3x3 ones matrix
|
|||
|
|
>>> # with the same arbitrary spacing
|
|||
|
|
>>> y = torch.ones(3, 3)
|
|||
|
|
>>> x = torch.tensor([1, 3, 6])
|
|||
|
|
>>> torch.cumulative_trapezoid(y, x)
|
|||
|
|
tensor([[2., 5.],
|
|||
|
|
[2., 5.],
|
|||
|
|
[2., 5.]])
|
|||
|
|
|
|||
|
|
>>> # Cumulatively computes the trapezoidal rule for each row of a 3x3 ones matrix
|
|||
|
|
>>> # with different arbitrary spacing per row
|
|||
|
|
>>> y = torch.ones(3, 3)
|
|||
|
|
>>> x = torch.tensor([[1, 2, 3], [1, 3, 5], [1, 4, 7]])
|
|||
|
|
>>> torch.cumulative_trapezoid(y, x)
|
|||
|
|
tensor([[1., 2.],
|
|||
|
|
[2., 4.],
|
|||
|
|
[3., 6.]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def cumulative_trapezoid(y: Tensor, *, dx: Union[Number, _complex] = 1, dim: _int = -1) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
cumulative_trapezoid(y, x=None, *, dx=None, dim=-1) -> Tensor
|
|||
|
|
|
|||
|
|
Cumulatively computes the `trapezoidal rule <https://en.wikipedia.org/wiki/Trapezoidal_rule>`_
|
|||
|
|
along :attr:`dim`. By default the spacing between elements is assumed to be 1, but
|
|||
|
|
:attr:`dx` can be used to specify a different constant spacing, and :attr:`x` can be
|
|||
|
|
used to specify arbitrary spacing along :attr:`dim`.
|
|||
|
|
|
|||
|
|
For more details, please read :func:`torch.trapezoid`. The difference between :func:`torch.trapezoid`
|
|||
|
|
and this function is that, :func:`torch.trapezoid` returns a value for each integration,
|
|||
|
|
where as this function returns a cumulative value for every spacing within the integration. This
|
|||
|
|
is analogous to how `.sum` returns a value and `.cumsum` returns a cumulative sum.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
y (Tensor): Values to use when computing the trapezoidal rule.
|
|||
|
|
x (Tensor): If specified, defines spacing between values as specified above.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
dx (float): constant spacing between values. If neither :attr:`x` or :attr:`dx`
|
|||
|
|
are specified then this defaults to 1. Effectively multiplies the result by its value.
|
|||
|
|
dim (int): The dimension along which to compute the trapezoidal rule.
|
|||
|
|
The last (inner-most) dimension by default.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> # Cumulatively computes the trapezoidal rule in 1D, spacing is implicitly 1.
|
|||
|
|
>>> y = torch.tensor([1, 5, 10])
|
|||
|
|
>>> torch.cumulative_trapezoid(y)
|
|||
|
|
tensor([3., 10.5])
|
|||
|
|
|
|||
|
|
>>> # Computes the same trapezoidal rule directly up to each element to verify
|
|||
|
|
>>> (1 + 5) / 2
|
|||
|
|
3.0
|
|||
|
|
>>> (1 + 10 + 10) / 2
|
|||
|
|
10.5
|
|||
|
|
|
|||
|
|
>>> # Cumulatively computes the trapezoidal rule in 1D with constant spacing of 2
|
|||
|
|
>>> # NOTE: the result is the same as before, but multiplied by 2
|
|||
|
|
>>> torch.cumulative_trapezoid(y, dx=2)
|
|||
|
|
tensor([6., 21.])
|
|||
|
|
|
|||
|
|
>>> # Cumulatively computes the trapezoidal rule in 1D with arbitrary spacing
|
|||
|
|
>>> x = torch.tensor([1, 3, 6])
|
|||
|
|
>>> torch.cumulative_trapezoid(y, x)
|
|||
|
|
tensor([6., 28.5])
|
|||
|
|
|
|||
|
|
>>> # Computes the same trapezoidal rule directly up to each element to verify
|
|||
|
|
>>> ((3 - 1) * (1 + 5)) / 2
|
|||
|
|
6.0
|
|||
|
|
>>> ((3 - 1) * (1 + 5) + (6 - 3) * (5 + 10)) / 2
|
|||
|
|
28.5
|
|||
|
|
|
|||
|
|
>>> # Cumulatively computes the trapezoidal rule for each row of a 3x3 matrix
|
|||
|
|
>>> y = torch.arange(9).reshape(3, 3)
|
|||
|
|
tensor([[0, 1, 2],
|
|||
|
|
[3, 4, 5],
|
|||
|
|
[6, 7, 8]])
|
|||
|
|
>>> torch.cumulative_trapezoid(y)
|
|||
|
|
tensor([[ 0.5, 2.],
|
|||
|
|
[ 3.5, 8.],
|
|||
|
|
[ 6.5, 14.]])
|
|||
|
|
|
|||
|
|
>>> # Cumulatively computes the trapezoidal rule for each column of the matrix
|
|||
|
|
>>> torch.cumulative_trapezoid(y, dim=0)
|
|||
|
|
tensor([[ 1.5, 2.5, 3.5],
|
|||
|
|
[ 6.0, 8.0, 10.0]])
|
|||
|
|
|
|||
|
|
>>> # Cumulatively computes the trapezoidal rule for each row of a 3x3 ones matrix
|
|||
|
|
>>> # with the same arbitrary spacing
|
|||
|
|
>>> y = torch.ones(3, 3)
|
|||
|
|
>>> x = torch.tensor([1, 3, 6])
|
|||
|
|
>>> torch.cumulative_trapezoid(y, x)
|
|||
|
|
tensor([[2., 5.],
|
|||
|
|
[2., 5.],
|
|||
|
|
[2., 5.]])
|
|||
|
|
|
|||
|
|
>>> # Cumulatively computes the trapezoidal rule for each row of a 3x3 ones matrix
|
|||
|
|
>>> # with different arbitrary spacing per row
|
|||
|
|
>>> y = torch.ones(3, 3)
|
|||
|
|
>>> x = torch.tensor([[1, 2, 3], [1, 3, 5], [1, 4, 7]])
|
|||
|
|
>>> torch.cumulative_trapezoid(y, x)
|
|||
|
|
tensor([[1., 2.],
|
|||
|
|
[2., 4.],
|
|||
|
|
[3., 6.]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def deg2rad(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
deg2rad(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with each of the elements of :attr:`input`
|
|||
|
|
converted from angles in degrees to radians.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([[180.0, -180.0], [360.0, -360.0], [90.0, -90.0]])
|
|||
|
|
>>> torch.deg2rad(a)
|
|||
|
|
tensor([[ 3.1416, -3.1416],
|
|||
|
|
[ 6.2832, -6.2832],
|
|||
|
|
[ 1.5708, -1.5708]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def deg2rad_(input: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def dequantize(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
dequantize(tensor) -> Tensor
|
|||
|
|
|
|||
|
|
Returns an fp32 Tensor by dequantizing a quantized Tensor
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
tensor (Tensor): A quantized Tensor
|
|||
|
|
|
|||
|
|
.. function:: dequantize(tensors) -> sequence of Tensors
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Given a list of quantized Tensors, dequantize them and return a list of fp32 Tensors
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
tensors (sequence of Tensors): A list of quantized Tensors
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def dequantize(tensors: Union[Tuple[Tensor, ...], List[Tensor]]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
dequantize(tensor) -> Tensor
|
|||
|
|
|
|||
|
|
Returns an fp32 Tensor by dequantizing a quantized Tensor
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
tensor (Tensor): A quantized Tensor
|
|||
|
|
|
|||
|
|
.. function:: dequantize(tensors) -> sequence of Tensors
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Given a list of quantized Tensors, dequantize them and return a list of fp32 Tensors
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
tensors (sequence of Tensors): A list of quantized Tensors
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def det(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
det(input) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.linalg.det`
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def detach(input: Tensor) -> Tensor: ...
|
|||
|
|
def detach_(input: Tensor) -> Tensor: ...
|
|||
|
|
def detach_copy(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.detach`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def diag(input: Tensor, diagonal: _int = 0, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
diag(input, diagonal=0, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
- If :attr:`input` is a vector (1-D tensor), then returns a 2-D square tensor
|
|||
|
|
with the elements of :attr:`input` as the diagonal.
|
|||
|
|
- If :attr:`input` is a matrix (2-D tensor), then returns a 1-D tensor with
|
|||
|
|
the diagonal elements of :attr:`input`.
|
|||
|
|
|
|||
|
|
The argument :attr:`diagonal` controls which diagonal to consider:
|
|||
|
|
|
|||
|
|
- If :attr:`diagonal` = 0, it is the main diagonal.
|
|||
|
|
- If :attr:`diagonal` > 0, it is above the main diagonal.
|
|||
|
|
- If :attr:`diagonal` < 0, it is below the main diagonal.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
diagonal (int, optional): the diagonal to consider
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.diagonal` always returns the diagonal of its input.
|
|||
|
|
|
|||
|
|
:func:`torch.diagflat` always constructs a tensor with diagonal elements
|
|||
|
|
specified by the input.
|
|||
|
|
|
|||
|
|
Examples:
|
|||
|
|
|
|||
|
|
Get the square matrix where the input vector is the diagonal::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 0.5950,-0.0872, 2.3298])
|
|||
|
|
>>> torch.diag(a)
|
|||
|
|
tensor([[ 0.5950, 0.0000, 0.0000],
|
|||
|
|
[ 0.0000,-0.0872, 0.0000],
|
|||
|
|
[ 0.0000, 0.0000, 2.3298]])
|
|||
|
|
>>> torch.diag(a, 1)
|
|||
|
|
tensor([[ 0.0000, 0.5950, 0.0000, 0.0000],
|
|||
|
|
[ 0.0000, 0.0000,-0.0872, 0.0000],
|
|||
|
|
[ 0.0000, 0.0000, 0.0000, 2.3298],
|
|||
|
|
[ 0.0000, 0.0000, 0.0000, 0.0000]])
|
|||
|
|
|
|||
|
|
Get the k-th diagonal of a given matrix::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(3, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[-0.4264, 0.0255,-0.1064],
|
|||
|
|
[ 0.8795,-0.2429, 0.1374],
|
|||
|
|
[ 0.1029,-0.6482,-1.6300]])
|
|||
|
|
>>> torch.diag(a, 0)
|
|||
|
|
tensor([-0.4264,-0.2429,-1.6300])
|
|||
|
|
>>> torch.diag(a, 1)
|
|||
|
|
tensor([ 0.0255, 0.1374])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def diag_embed(input: Tensor, offset: _int = 0, dim1: _int = -2, dim2: _int = -1) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
diag_embed(input, offset=0, dim1=-2, dim2=-1) -> Tensor
|
|||
|
|
|
|||
|
|
Creates a tensor whose diagonals of certain 2D planes (specified by
|
|||
|
|
:attr:`dim1` and :attr:`dim2`) are filled by :attr:`input`.
|
|||
|
|
To facilitate creating batched diagonal matrices, the 2D planes formed by
|
|||
|
|
the last two dimensions of the returned tensor are chosen by default.
|
|||
|
|
|
|||
|
|
The argument :attr:`offset` controls which diagonal to consider:
|
|||
|
|
|
|||
|
|
- If :attr:`offset` = 0, it is the main diagonal.
|
|||
|
|
- If :attr:`offset` > 0, it is above the main diagonal.
|
|||
|
|
- If :attr:`offset` < 0, it is below the main diagonal.
|
|||
|
|
|
|||
|
|
The size of the new matrix will be calculated to make the specified diagonal
|
|||
|
|
of the size of the last input dimension.
|
|||
|
|
Note that for :attr:`offset` other than :math:`0`, the order of :attr:`dim1`
|
|||
|
|
and :attr:`dim2` matters. Exchanging them is equivalent to changing the
|
|||
|
|
sign of :attr:`offset`.
|
|||
|
|
|
|||
|
|
Applying :meth:`torch.diagonal` to the output of this function with
|
|||
|
|
the same arguments yields a matrix identical to input. However,
|
|||
|
|
:meth:`torch.diagonal` has different default dimensions, so those
|
|||
|
|
need to be explicitly specified.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor. Must be at least 1-dimensional.
|
|||
|
|
offset (int, optional): which diagonal to consider. Default: 0
|
|||
|
|
(main diagonal).
|
|||
|
|
dim1 (int, optional): first dimension with respect to which to
|
|||
|
|
take diagonal. Default: -2.
|
|||
|
|
dim2 (int, optional): second dimension with respect to which to
|
|||
|
|
take diagonal. Default: -1.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(2, 3)
|
|||
|
|
>>> torch.diag_embed(a)
|
|||
|
|
tensor([[[ 1.5410, 0.0000, 0.0000],
|
|||
|
|
[ 0.0000, -0.2934, 0.0000],
|
|||
|
|
[ 0.0000, 0.0000, -2.1788]],
|
|||
|
|
|
|||
|
|
[[ 0.5684, 0.0000, 0.0000],
|
|||
|
|
[ 0.0000, -1.0845, 0.0000],
|
|||
|
|
[ 0.0000, 0.0000, -1.3986]]])
|
|||
|
|
|
|||
|
|
>>> torch.diag_embed(a, offset=1, dim1=0, dim2=2)
|
|||
|
|
tensor([[[ 0.0000, 1.5410, 0.0000, 0.0000],
|
|||
|
|
[ 0.0000, 0.5684, 0.0000, 0.0000]],
|
|||
|
|
|
|||
|
|
[[ 0.0000, 0.0000, -0.2934, 0.0000],
|
|||
|
|
[ 0.0000, 0.0000, -1.0845, 0.0000]],
|
|||
|
|
|
|||
|
|
[[ 0.0000, 0.0000, 0.0000, -2.1788],
|
|||
|
|
[ 0.0000, 0.0000, 0.0000, -1.3986]],
|
|||
|
|
|
|||
|
|
[[ 0.0000, 0.0000, 0.0000, 0.0000],
|
|||
|
|
[ 0.0000, 0.0000, 0.0000, 0.0000]]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def diagflat(input: Tensor, offset: _int = 0) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
diagflat(input, offset=0) -> Tensor
|
|||
|
|
|
|||
|
|
- If :attr:`input` is a vector (1-D tensor), then returns a 2-D square tensor
|
|||
|
|
with the elements of :attr:`input` as the diagonal.
|
|||
|
|
- If :attr:`input` is a tensor with more than one dimension, then returns a
|
|||
|
|
2-D tensor with diagonal elements equal to a flattened :attr:`input`.
|
|||
|
|
|
|||
|
|
The argument :attr:`offset` controls which diagonal to consider:
|
|||
|
|
|
|||
|
|
- If :attr:`offset` = 0, it is the main diagonal.
|
|||
|
|
- If :attr:`offset` > 0, it is above the main diagonal.
|
|||
|
|
- If :attr:`offset` < 0, it is below the main diagonal.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
offset (int, optional): the diagonal to consider. Default: 0 (main
|
|||
|
|
diagonal).
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([-0.2956, -0.9068, 0.1695])
|
|||
|
|
>>> torch.diagflat(a)
|
|||
|
|
tensor([[-0.2956, 0.0000, 0.0000],
|
|||
|
|
[ 0.0000, -0.9068, 0.0000],
|
|||
|
|
[ 0.0000, 0.0000, 0.1695]])
|
|||
|
|
>>> torch.diagflat(a, 1)
|
|||
|
|
tensor([[ 0.0000, -0.2956, 0.0000, 0.0000],
|
|||
|
|
[ 0.0000, 0.0000, -0.9068, 0.0000],
|
|||
|
|
[ 0.0000, 0.0000, 0.0000, 0.1695],
|
|||
|
|
[ 0.0000, 0.0000, 0.0000, 0.0000]])
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(2, 2)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.2094, -0.3018],
|
|||
|
|
[-0.1516, 1.9342]])
|
|||
|
|
>>> torch.diagflat(a)
|
|||
|
|
tensor([[ 0.2094, 0.0000, 0.0000, 0.0000],
|
|||
|
|
[ 0.0000, -0.3018, 0.0000, 0.0000],
|
|||
|
|
[ 0.0000, 0.0000, -0.1516, 0.0000],
|
|||
|
|
[ 0.0000, 0.0000, 0.0000, 1.9342]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def diagonal(input: Tensor, offset: _int = 0, dim1: _int = 0, dim2: _int = 1) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
diagonal(input, offset=0, dim1=0, dim2=1) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a partial view of :attr:`input` with the its diagonal elements
|
|||
|
|
with respect to :attr:`dim1` and :attr:`dim2` appended as a dimension
|
|||
|
|
at the end of the shape.
|
|||
|
|
|
|||
|
|
The argument :attr:`offset` controls which diagonal to consider:
|
|||
|
|
|
|||
|
|
- If :attr:`offset` = 0, it is the main diagonal.
|
|||
|
|
- If :attr:`offset` > 0, it is above the main diagonal.
|
|||
|
|
- If :attr:`offset` < 0, it is below the main diagonal.
|
|||
|
|
|
|||
|
|
Applying :meth:`torch.diag_embed` to the output of this function with
|
|||
|
|
the same arguments yields a diagonal matrix with the diagonal entries
|
|||
|
|
of the input. However, :meth:`torch.diag_embed` has different default
|
|||
|
|
dimensions, so those need to be explicitly specified.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor. Must be at least 2-dimensional.
|
|||
|
|
offset (int, optional): which diagonal to consider. Default: 0
|
|||
|
|
(main diagonal).
|
|||
|
|
dim1 (int, optional): first dimension with respect to which to
|
|||
|
|
take diagonal. Default: 0.
|
|||
|
|
dim2 (int, optional): second dimension with respect to which to
|
|||
|
|
take diagonal. Default: 1.
|
|||
|
|
|
|||
|
|
.. note:: To take a batch diagonal, pass in dim1=-2, dim2=-1.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(3, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[-1.0854, 1.1431, -0.1752],
|
|||
|
|
[ 0.8536, -0.0905, 0.0360],
|
|||
|
|
[ 0.6927, -0.3735, -0.4945]])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> torch.diagonal(a, 0)
|
|||
|
|
tensor([-1.0854, -0.0905, -0.4945])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> torch.diagonal(a, 1)
|
|||
|
|
tensor([ 1.1431, 0.0360])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(2, 5, 4, 2)
|
|||
|
|
>>> torch.diagonal(x, offset=-1, dim1=1, dim2=2)
|
|||
|
|
tensor([[[-1.2631, 0.3755, -1.5977, -1.8172],
|
|||
|
|
[-1.1065, 1.0401, -0.2235, -0.7938]],
|
|||
|
|
|
|||
|
|
[[-1.7325, -0.3081, 0.6166, 0.2335],
|
|||
|
|
[ 1.0500, 0.7336, -0.3836, -1.1015]]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def diagonal(input: Tensor, *, outdim: Union[str, ellipsis, None], dim1: Union[str, ellipsis, None], dim2: Union[str, ellipsis, None], offset: _int = 0) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
diagonal(input, offset=0, dim1=0, dim2=1) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a partial view of :attr:`input` with the its diagonal elements
|
|||
|
|
with respect to :attr:`dim1` and :attr:`dim2` appended as a dimension
|
|||
|
|
at the end of the shape.
|
|||
|
|
|
|||
|
|
The argument :attr:`offset` controls which diagonal to consider:
|
|||
|
|
|
|||
|
|
- If :attr:`offset` = 0, it is the main diagonal.
|
|||
|
|
- If :attr:`offset` > 0, it is above the main diagonal.
|
|||
|
|
- If :attr:`offset` < 0, it is below the main diagonal.
|
|||
|
|
|
|||
|
|
Applying :meth:`torch.diag_embed` to the output of this function with
|
|||
|
|
the same arguments yields a diagonal matrix with the diagonal entries
|
|||
|
|
of the input. However, :meth:`torch.diag_embed` has different default
|
|||
|
|
dimensions, so those need to be explicitly specified.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor. Must be at least 2-dimensional.
|
|||
|
|
offset (int, optional): which diagonal to consider. Default: 0
|
|||
|
|
(main diagonal).
|
|||
|
|
dim1 (int, optional): first dimension with respect to which to
|
|||
|
|
take diagonal. Default: 0.
|
|||
|
|
dim2 (int, optional): second dimension with respect to which to
|
|||
|
|
take diagonal. Default: 1.
|
|||
|
|
|
|||
|
|
.. note:: To take a batch diagonal, pass in dim1=-2, dim2=-1.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(3, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[-1.0854, 1.1431, -0.1752],
|
|||
|
|
[ 0.8536, -0.0905, 0.0360],
|
|||
|
|
[ 0.6927, -0.3735, -0.4945]])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> torch.diagonal(a, 0)
|
|||
|
|
tensor([-1.0854, -0.0905, -0.4945])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> torch.diagonal(a, 1)
|
|||
|
|
tensor([ 1.1431, 0.0360])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(2, 5, 4, 2)
|
|||
|
|
>>> torch.diagonal(x, offset=-1, dim1=1, dim2=2)
|
|||
|
|
tensor([[[-1.2631, 0.3755, -1.5977, -1.8172],
|
|||
|
|
[-1.1065, 1.0401, -0.2235, -0.7938]],
|
|||
|
|
|
|||
|
|
[[-1.7325, -0.3081, 0.6166, 0.2335],
|
|||
|
|
[ 1.0500, 0.7336, -0.3836, -1.1015]]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def diagonal_copy(input: Tensor, offset: _int = 0, dim1: _int = 0, dim2: _int = 1, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.diagonal`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def diagonal_scatter(input: Tensor, src: Tensor, offset: _int = 0, dim1: _int = 0, dim2: _int = 1) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
diagonal_scatter(input, src, offset=0, dim1=0, dim2=1) -> Tensor
|
|||
|
|
|
|||
|
|
Embeds the values of the :attr:`src` tensor into :attr:`input` along
|
|||
|
|
the diagonal elements of :attr:`input`, with respect to :attr:`dim1`
|
|||
|
|
and :attr:`dim2`.
|
|||
|
|
|
|||
|
|
This function returns a tensor with fresh storage; it does not
|
|||
|
|
return a view.
|
|||
|
|
|
|||
|
|
The argument :attr:`offset` controls which diagonal to consider:
|
|||
|
|
|
|||
|
|
- If :attr:`offset` = 0, it is the main diagonal.
|
|||
|
|
- If :attr:`offset` > 0, it is above the main diagonal.
|
|||
|
|
- If :attr:`offset` < 0, it is below the main diagonal.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor. Must be at least 2-dimensional.
|
|||
|
|
src (Tensor): the tensor to embed into :attr:`input`.
|
|||
|
|
offset (int, optional): which diagonal to consider. Default: 0
|
|||
|
|
(main diagonal).
|
|||
|
|
dim1 (int, optional): first dimension with respect to which to
|
|||
|
|
take diagonal. Default: 0.
|
|||
|
|
dim2 (int, optional): second dimension with respect to which to
|
|||
|
|
take diagonal. Default: 1.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
:attr:`src` must be of the proper size in order to be embedded
|
|||
|
|
into :attr:`input`. Specifically, it should have the same shape as
|
|||
|
|
``torch.diagonal(input, offset, dim1, dim2)``
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> a = torch.zeros(3, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[0., 0., 0.],
|
|||
|
|
[0., 0., 0.],
|
|||
|
|
[0., 0., 0.]])
|
|||
|
|
|
|||
|
|
>>> torch.diagonal_scatter(a, torch.ones(3), 0)
|
|||
|
|
tensor([[1., 0., 0.],
|
|||
|
|
[0., 1., 0.],
|
|||
|
|
[0., 0., 1.]])
|
|||
|
|
|
|||
|
|
>>> torch.diagonal_scatter(a, torch.ones(2), 1)
|
|||
|
|
tensor([[0., 1., 0.],
|
|||
|
|
[0., 0., 1.],
|
|||
|
|
[0., 0., 0.]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def diff(input: Tensor, n: _int = 1, dim: _int = -1, prepend: Optional[Tensor] = None, append: Optional[Tensor] = None, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
diff(input, n=1, dim=-1, prepend=None, append=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the n-th forward difference along the given dimension.
|
|||
|
|
|
|||
|
|
The first-order differences are given by `out[i] = input[i + 1] - input[i]`. Higher-order
|
|||
|
|
differences are calculated by using :func:`torch.diff` recursively.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to compute the differences on
|
|||
|
|
n (int, optional): the number of times to recursively compute the difference
|
|||
|
|
dim (int, optional): the dimension to compute the difference along.
|
|||
|
|
Default is the last dimension.
|
|||
|
|
prepend, append (Tensor, optional): values to prepend or append to
|
|||
|
|
:attr:`input` along :attr:`dim` before computing the difference.
|
|||
|
|
Their dimensions must be equivalent to that of input, and their shapes
|
|||
|
|
must match input's shape except on :attr:`dim`.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([1, 3, 2])
|
|||
|
|
>>> torch.diff(a)
|
|||
|
|
tensor([ 2, -1])
|
|||
|
|
>>> b = torch.tensor([4, 5])
|
|||
|
|
>>> torch.diff(a, append=b)
|
|||
|
|
tensor([ 2, -1, 2, 1])
|
|||
|
|
>>> c = torch.tensor([[1, 2, 3], [3, 4, 5]])
|
|||
|
|
>>> torch.diff(c, dim=0)
|
|||
|
|
tensor([[2, 2, 2]])
|
|||
|
|
>>> torch.diff(c, dim=1)
|
|||
|
|
tensor([[1, 1],
|
|||
|
|
[1, 1]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def digamma(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
digamma(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.special.digamma`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def dist(input: Tensor, other: Tensor, p: Union[Number, _complex] = 2) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
dist(input, other, p=2) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the p-norm of (:attr:`input` - :attr:`other`)
|
|||
|
|
|
|||
|
|
The shapes of :attr:`input` and :attr:`other` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
other (Tensor): the Right-hand-side input tensor
|
|||
|
|
p (float, optional): the norm to be computed
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(4)
|
|||
|
|
>>> x
|
|||
|
|
tensor([-1.5393, -0.8675, 0.5916, 1.6321])
|
|||
|
|
>>> y = torch.randn(4)
|
|||
|
|
>>> y
|
|||
|
|
tensor([ 0.0967, -1.0511, 0.6295, 0.8360])
|
|||
|
|
>>> torch.dist(x, y, 3.5)
|
|||
|
|
tensor(1.6727)
|
|||
|
|
>>> torch.dist(x, y, 3)
|
|||
|
|
tensor(1.6973)
|
|||
|
|
>>> torch.dist(x, y, 0)
|
|||
|
|
tensor(4.)
|
|||
|
|
>>> torch.dist(x, y, 1)
|
|||
|
|
tensor(2.6537)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def div(input: Union[Tensor, Number], other: Union[Tensor, Number], *, rounding_mode: Optional[str] = None, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
div(input, other, *, rounding_mode=None, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Divides each element of the input ``input`` by the corresponding element of
|
|||
|
|
:attr:`other`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \frac{\text{input}_i}{\text{other}_i}
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
By default, this performs a "true" division like Python 3.
|
|||
|
|
See the :attr:`rounding_mode` argument for floor division.
|
|||
|
|
|
|||
|
|
Supports :ref:`broadcasting to a common shape <broadcasting-semantics>`,
|
|||
|
|
:ref:`type promotion <type-promotion-doc>`, and integer, float, and complex inputs.
|
|||
|
|
Always promotes integer types to the default scalar type.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the dividend
|
|||
|
|
other (Tensor or Number): the divisor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
rounding_mode (str, optional): Type of rounding applied to the result:
|
|||
|
|
|
|||
|
|
* None - default behavior. Performs no rounding and, if both :attr:`input` and
|
|||
|
|
:attr:`other` are integer types, promotes the inputs to the default scalar type.
|
|||
|
|
Equivalent to true division in Python (the ``/`` operator) and NumPy's ``np.true_divide``.
|
|||
|
|
* ``"trunc"`` - rounds the results of the division towards zero.
|
|||
|
|
Equivalent to C-style integer division.
|
|||
|
|
* ``"floor"`` - rounds the results of the division down.
|
|||
|
|
Equivalent to floor division in Python (the ``//`` operator) and NumPy's ``np.floor_divide``.
|
|||
|
|
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> x = torch.tensor([ 0.3810, 1.2774, -0.2972, -0.3719, 0.4637])
|
|||
|
|
>>> torch.div(x, 0.5)
|
|||
|
|
tensor([ 0.7620, 2.5548, -0.5944, -0.7438, 0.9274])
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([[-0.3711, -1.9353, -0.4605, -0.2917],
|
|||
|
|
... [ 0.1815, -1.0111, 0.9805, -1.5923],
|
|||
|
|
... [ 0.1062, 1.4581, 0.7759, -1.2344],
|
|||
|
|
... [-0.1830, -0.0313, 1.1908, -1.4757]])
|
|||
|
|
>>> b = torch.tensor([ 0.8032, 0.2930, -0.8113, -0.2308])
|
|||
|
|
>>> torch.div(a, b)
|
|||
|
|
tensor([[-0.4620, -6.6051, 0.5676, 1.2639],
|
|||
|
|
[ 0.2260, -3.4509, -1.2086, 6.8990],
|
|||
|
|
[ 0.1322, 4.9764, -0.9564, 5.3484],
|
|||
|
|
[-0.2278, -0.1068, -1.4678, 6.3938]])
|
|||
|
|
|
|||
|
|
>>> torch.div(a, b, rounding_mode='trunc')
|
|||
|
|
tensor([[-0., -6., 0., 1.],
|
|||
|
|
[ 0., -3., -1., 6.],
|
|||
|
|
[ 0., 4., -0., 5.],
|
|||
|
|
[-0., -0., -1., 6.]])
|
|||
|
|
|
|||
|
|
>>> torch.div(a, b, rounding_mode='floor')
|
|||
|
|
tensor([[-1., -7., 0., 1.],
|
|||
|
|
[ 0., -4., -2., 6.],
|
|||
|
|
[ 0., 4., -1., 5.],
|
|||
|
|
[-1., -1., -2., 6.]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def divide(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
divide(input, other, *, rounding_mode=None, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.div`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def divide(input: Tensor, other: Tensor, *, rounding_mode: Optional[str], out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
divide(input, other, *, rounding_mode=None, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.div`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def divide(input: Tensor, other: Union[Number, _complex], *, rounding_mode: Optional[str]) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
divide(input, other, *, rounding_mode=None, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.div`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def divide(input: Tensor, other: Union[Number, _complex]) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
divide(input, other, *, rounding_mode=None, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.div`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def dot(input: Tensor, tensor: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
dot(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the dot product of two 1D tensors.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
Unlike NumPy's dot, torch.dot intentionally only supports computing the dot product
|
|||
|
|
of two 1D tensors with the same number of elements.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): first tensor in the dot product, must be 1D.
|
|||
|
|
other (Tensor): second tensor in the dot product, must be 1D.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.dot(torch.tensor([2, 3]), torch.tensor([2, 1]))
|
|||
|
|
tensor(7)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def dropout(input: Tensor, p: _float, train: _bool) -> Tensor: ...
|
|||
|
|
def dropout_(input: Tensor, p: _float, train: _bool) -> Tensor: ...
|
|||
|
|
def dsmm(input: Tensor, mat2: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def dsplit(input: Tensor, sections: _int) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
dsplit(input, indices_or_sections) -> List of Tensors
|
|||
|
|
|
|||
|
|
Splits :attr:`input`, a tensor with three or more dimensions, into multiple tensors
|
|||
|
|
depthwise according to :attr:`indices_or_sections`. Each split is a view of
|
|||
|
|
:attr:`input`.
|
|||
|
|
|
|||
|
|
This is equivalent to calling torch.tensor_split(input, indices_or_sections, dim=2)
|
|||
|
|
(the split dimension is 2), except that if :attr:`indices_or_sections` is an integer
|
|||
|
|
it must evenly divide the split dimension or a runtime error will be thrown.
|
|||
|
|
|
|||
|
|
This function is based on NumPy's :func:`numpy.dsplit`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): tensor to split.
|
|||
|
|
indices_or_sections (int or list or tuple of ints): See argument in :func:`torch.tensor_split`.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
>>> t = torch.arange(16.0).reshape(2, 2, 4)
|
|||
|
|
>>> t
|
|||
|
|
tensor([[[ 0., 1., 2., 3.],
|
|||
|
|
[ 4., 5., 6., 7.]],
|
|||
|
|
[[ 8., 9., 10., 11.],
|
|||
|
|
[12., 13., 14., 15.]]])
|
|||
|
|
>>> torch.dsplit(t, 2)
|
|||
|
|
(tensor([[[ 0., 1.],
|
|||
|
|
[ 4., 5.]],
|
|||
|
|
[[ 8., 9.],
|
|||
|
|
[12., 13.]]]),
|
|||
|
|
tensor([[[ 2., 3.],
|
|||
|
|
[ 6., 7.]],
|
|||
|
|
[[10., 11.],
|
|||
|
|
[14., 15.]]]))
|
|||
|
|
|
|||
|
|
>>> torch.dsplit(t, [3, 6])
|
|||
|
|
(tensor([[[ 0., 1., 2.],
|
|||
|
|
[ 4., 5., 6.]],
|
|||
|
|
[[ 8., 9., 10.],
|
|||
|
|
[12., 13., 14.]]]),
|
|||
|
|
tensor([[[ 3.],
|
|||
|
|
[ 7.]],
|
|||
|
|
[[11.],
|
|||
|
|
[15.]]]),
|
|||
|
|
tensor([], size=(2, 2, 0)))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def dsplit(input: Tensor, indices: _size) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
dsplit(input, indices_or_sections) -> List of Tensors
|
|||
|
|
|
|||
|
|
Splits :attr:`input`, a tensor with three or more dimensions, into multiple tensors
|
|||
|
|
depthwise according to :attr:`indices_or_sections`. Each split is a view of
|
|||
|
|
:attr:`input`.
|
|||
|
|
|
|||
|
|
This is equivalent to calling torch.tensor_split(input, indices_or_sections, dim=2)
|
|||
|
|
(the split dimension is 2), except that if :attr:`indices_or_sections` is an integer
|
|||
|
|
it must evenly divide the split dimension or a runtime error will be thrown.
|
|||
|
|
|
|||
|
|
This function is based on NumPy's :func:`numpy.dsplit`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): tensor to split.
|
|||
|
|
indices_or_sections (int or list or tuple of ints): See argument in :func:`torch.tensor_split`.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
>>> t = torch.arange(16.0).reshape(2, 2, 4)
|
|||
|
|
>>> t
|
|||
|
|
tensor([[[ 0., 1., 2., 3.],
|
|||
|
|
[ 4., 5., 6., 7.]],
|
|||
|
|
[[ 8., 9., 10., 11.],
|
|||
|
|
[12., 13., 14., 15.]]])
|
|||
|
|
>>> torch.dsplit(t, 2)
|
|||
|
|
(tensor([[[ 0., 1.],
|
|||
|
|
[ 4., 5.]],
|
|||
|
|
[[ 8., 9.],
|
|||
|
|
[12., 13.]]]),
|
|||
|
|
tensor([[[ 2., 3.],
|
|||
|
|
[ 6., 7.]],
|
|||
|
|
[[10., 11.],
|
|||
|
|
[14., 15.]]]))
|
|||
|
|
|
|||
|
|
>>> torch.dsplit(t, [3, 6])
|
|||
|
|
(tensor([[[ 0., 1., 2.],
|
|||
|
|
[ 4., 5., 6.]],
|
|||
|
|
[[ 8., 9., 10.],
|
|||
|
|
[12., 13., 14.]]]),
|
|||
|
|
tensor([[[ 3.],
|
|||
|
|
[ 7.]],
|
|||
|
|
[[11.],
|
|||
|
|
[15.]]]),
|
|||
|
|
tensor([], size=(2, 2, 0)))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def dstack(tensors: Union[Tuple[Tensor, ...], List[Tensor]], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
dstack(tensors, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Stack tensors in sequence depthwise (along third axis).
|
|||
|
|
|
|||
|
|
This is equivalent to concatenation along the third axis after 1-D and 2-D tensors have been reshaped by :func:`torch.atleast_3d`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
tensors (sequence of Tensors): sequence of tensors to concatenate
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([1, 2, 3])
|
|||
|
|
>>> b = torch.tensor([4, 5, 6])
|
|||
|
|
>>> torch.dstack((a,b))
|
|||
|
|
tensor([[[1, 4],
|
|||
|
|
[2, 5],
|
|||
|
|
[3, 6]]])
|
|||
|
|
>>> a = torch.tensor([[1],[2],[3]])
|
|||
|
|
>>> b = torch.tensor([[4],[5],[6]])
|
|||
|
|
>>> torch.dstack((a,b))
|
|||
|
|
tensor([[[1, 4]],
|
|||
|
|
[[2, 5]],
|
|||
|
|
[[3, 6]]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def embedding(weight: Tensor, indices: Tensor, padding_idx: Union[_int, SymInt] = -1, scale_grad_by_freq: _bool = False, sparse: _bool = False) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def embedding_bag(weight: Tensor, indices: Tensor, offsets: Tensor, scale_grad_by_freq: _bool, mode: _int, sparse: _bool, per_sample_weights: Optional[Tensor], include_last_offset: _bool, padding_idx: Optional[_int]) -> Tuple[Tensor, Tensor, Tensor, Tensor]: ...
|
|||
|
|
@overload
|
|||
|
|
def embedding_bag(weight: Tensor, indices: Tensor, offsets: Tensor, scale_grad_by_freq: _bool = False, mode: _int = 0, sparse: _bool = False, per_sample_weights: Optional[Tensor] = None, include_last_offset: _bool = False) -> Tuple[Tensor, Tensor, Tensor, Tensor]: ...
|
|||
|
|
def embedding_renorm_(input: Tensor, indices: Tensor, max_norm: _float, norm_type: _float) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def empty(size: Sequence[Union[_int, SymInt]], *, memory_format: Optional[memory_format] = None, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
empty(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False, memory_format=torch.contiguous_format) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with uninitialized data. The shape of the tensor is
|
|||
|
|
defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If :func:`torch.use_deterministic_algorithms()` and
|
|||
|
|
:attr:`torch.utils.deterministic.fill_uninitialized_memory` are both set to
|
|||
|
|
``True``, the output tensor is initialized to prevent any possible
|
|||
|
|
nondeterministic behavior from using the data as an input to an operation.
|
|||
|
|
Floating point and complex tensors are filled with NaN, and integer tensors
|
|||
|
|
are filled with the maximum value.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
memory_format (:class:`torch.memory_format`, optional): the desired memory format of
|
|||
|
|
returned Tensor. Default: ``torch.contiguous_format``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.empty((2,3), dtype=torch.int64)
|
|||
|
|
tensor([[ 9.4064e+13, 2.8000e+01, 9.3493e+13],
|
|||
|
|
[ 7.5751e+18, 7.1428e+18, 7.5955e+18]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def empty(*size: _int, memory_format: Optional[memory_format] = None, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
empty(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False, memory_format=torch.contiguous_format) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with uninitialized data. The shape of the tensor is
|
|||
|
|
defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If :func:`torch.use_deterministic_algorithms()` and
|
|||
|
|
:attr:`torch.utils.deterministic.fill_uninitialized_memory` are both set to
|
|||
|
|
``True``, the output tensor is initialized to prevent any possible
|
|||
|
|
nondeterministic behavior from using the data as an input to an operation.
|
|||
|
|
Floating point and complex tensors are filled with NaN, and integer tensors
|
|||
|
|
are filled with the maximum value.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
memory_format (:class:`torch.memory_format`, optional): the desired memory format of
|
|||
|
|
returned Tensor. Default: ``torch.contiguous_format``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.empty((2,3), dtype=torch.int64)
|
|||
|
|
tensor([[ 9.4064e+13, 2.8000e+01, 9.3493e+13],
|
|||
|
|
[ 7.5751e+18, 7.1428e+18, 7.5955e+18]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def empty(size: _size, *, names: Optional[Sequence[Union[str, ellipsis, None]]], memory_format: Optional[memory_format] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
empty(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False, memory_format=torch.contiguous_format) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with uninitialized data. The shape of the tensor is
|
|||
|
|
defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If :func:`torch.use_deterministic_algorithms()` and
|
|||
|
|
:attr:`torch.utils.deterministic.fill_uninitialized_memory` are both set to
|
|||
|
|
``True``, the output tensor is initialized to prevent any possible
|
|||
|
|
nondeterministic behavior from using the data as an input to an operation.
|
|||
|
|
Floating point and complex tensors are filled with NaN, and integer tensors
|
|||
|
|
are filled with the maximum value.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
memory_format (:class:`torch.memory_format`, optional): the desired memory format of
|
|||
|
|
returned Tensor. Default: ``torch.contiguous_format``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.empty((2,3), dtype=torch.int64)
|
|||
|
|
tensor([[ 9.4064e+13, 2.8000e+01, 9.3493e+13],
|
|||
|
|
[ 7.5751e+18, 7.1428e+18, 7.5955e+18]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def empty(*size: _int, names: Optional[Sequence[Union[str, ellipsis, None]]], memory_format: Optional[memory_format] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
empty(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False, memory_format=torch.contiguous_format) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with uninitialized data. The shape of the tensor is
|
|||
|
|
defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If :func:`torch.use_deterministic_algorithms()` and
|
|||
|
|
:attr:`torch.utils.deterministic.fill_uninitialized_memory` are both set to
|
|||
|
|
``True``, the output tensor is initialized to prevent any possible
|
|||
|
|
nondeterministic behavior from using the data as an input to an operation.
|
|||
|
|
Floating point and complex tensors are filled with NaN, and integer tensors
|
|||
|
|
are filled with the maximum value.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
memory_format (:class:`torch.memory_format`, optional): the desired memory format of
|
|||
|
|
returned Tensor. Default: ``torch.contiguous_format``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.empty((2,3), dtype=torch.int64)
|
|||
|
|
tensor([[ 9.4064e+13, 2.8000e+01, 9.3493e+13],
|
|||
|
|
[ 7.5751e+18, 7.1428e+18, 7.5955e+18]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def empty_like(input: Tensor, *, memory_format: Optional[memory_format] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
empty_like(input, *, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format) -> Tensor
|
|||
|
|
|
|||
|
|
Returns an uninitialized tensor with the same size as :attr:`input`.
|
|||
|
|
``torch.empty_like(input)`` is equivalent to
|
|||
|
|
``torch.empty(input.size(), dtype=input.dtype, layout=input.layout, device=input.device)``.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If :func:`torch.use_deterministic_algorithms()` and
|
|||
|
|
:attr:`torch.utils.deterministic.fill_uninitialized_memory` are both set to
|
|||
|
|
``True``, the output tensor is initialized to prevent any possible
|
|||
|
|
nondeterministic behavior from using the data as an input to an operation.
|
|||
|
|
Floating point and complex tensors are filled with NaN, and integer tensors
|
|||
|
|
are filled with the maximum value.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the size of :attr:`input` will determine size of the output tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned Tensor.
|
|||
|
|
Default: if ``None``, defaults to the dtype of :attr:`input`.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned tensor.
|
|||
|
|
Default: if ``None``, defaults to the layout of :attr:`input`.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, defaults to the device of :attr:`input`.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
memory_format (:class:`torch.memory_format`, optional): the desired memory format of
|
|||
|
|
returned Tensor. Default: ``torch.preserve_format``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a=torch.empty((2,3), dtype=torch.int32, device = 'cuda')
|
|||
|
|
>>> torch.empty_like(a)
|
|||
|
|
tensor([[0, 0, 0],
|
|||
|
|
[0, 0, 0]], device='cuda:0', dtype=torch.int32)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def empty_permuted(size: Sequence[Union[_int, SymInt]], physical_layout: _size, *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
empty_permuted(size, physical_layout, *, dtype=None, layout=None, device=None, requires_grad=False, pin_memory=False) -> Tensor
|
|||
|
|
|
|||
|
|
Creates an uninitialized, non-overlapping and dense tensor with the
|
|||
|
|
specified :attr:`size`, with :attr:`physical_layout` specifying how the
|
|||
|
|
dimensions are physically laid out in memory (each logical dimension is listed
|
|||
|
|
from outermost to innermost). :attr:`physical_layout` is a generalization
|
|||
|
|
of NCHW/NHWC notation: if each dimension is assigned a number according to
|
|||
|
|
what order they occur in size (N=0, C=1, H=2, W=3), then NCHW is ``(0, 1, 2, 3)``
|
|||
|
|
while NHWC is ``(0, 2, 3, 1)``. Equivalently, the strides of the output
|
|||
|
|
tensor ``t`` are such that ``t.stride(physical_layout[i]) == contiguous_strides[i]``
|
|||
|
|
(notably, this function is *not* equivalent to ``torch.empty(size).permute(physical_layout)``).
|
|||
|
|
|
|||
|
|
Unlike :func:`torch.empty_strided`, this is guaranteed to produce a dense
|
|||
|
|
tensor with no overlaps. If possible, prefer using this function over
|
|||
|
|
:func:`torch.empty_strided` or manual use of :func:`torch.as_strided`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If :func:`torch.use_deterministic_algorithms()` and
|
|||
|
|
:attr:`torch.utils.deterministic.fill_uninitialized_memory` are both set to
|
|||
|
|
``True``, the output tensor is initialized to prevent any possible
|
|||
|
|
nondeterministic behavior from using the data as an input to an operation.
|
|||
|
|
Floating point and complex tensors are filled with NaN, and integer tensors
|
|||
|
|
are filled with the maximum value.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (tuple of int): the shape of the output tensor
|
|||
|
|
physical_layout (tuple of int): the ordering of dimensions physically in memory
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
|
|||
|
|
Examples:
|
|||
|
|
|
|||
|
|
>>> torch.empty((2, 3, 5, 7)).stride()
|
|||
|
|
(105, 35, 7, 1)
|
|||
|
|
>>> torch.empty_permuted((2, 3, 5, 7), (0, 1, 2, 3)).stride()
|
|||
|
|
(105, 35, 7, 1)
|
|||
|
|
>>> torch.empty((2, 3, 5, 7), memory_format=torch.channels_last).stride()
|
|||
|
|
(105, 1, 21, 3)
|
|||
|
|
>>> torch.empty_permuted((2, 3, 5, 7), (0, 2, 3, 1)).stride()
|
|||
|
|
(105, 1, 21, 3)
|
|||
|
|
>>> torch.empty_permuted((2, 3, 5, 7), (0, 2, 3, 1)).dim_order()
|
|||
|
|
(0, 2, 3, 1)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def empty_quantized(size: _size, qtensor: Tensor, *, memory_format: Optional[memory_format] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor: ...
|
|||
|
|
def empty_strided(size: Sequence[Union[_int, SymInt]], stride: Sequence[Union[_int, SymInt]], *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
empty_strided(size, stride, *, dtype=None, layout=None, device=None, requires_grad=False, pin_memory=False) -> Tensor
|
|||
|
|
|
|||
|
|
Creates a tensor with the specified :attr:`size` and :attr:`stride` and filled with undefined data.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
If the constructed tensor is "overlapped" (with multiple indices referring to the same element
|
|||
|
|
in memory) its behavior is undefined.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If :func:`torch.use_deterministic_algorithms()` and
|
|||
|
|
:attr:`torch.utils.deterministic.fill_uninitialized_memory` are both set to
|
|||
|
|
``True``, the output tensor is initialized to prevent any possible
|
|||
|
|
nondeterministic behavior from using the data as an input to an operation.
|
|||
|
|
Floating point and complex tensors are filled with NaN, and integer tensors
|
|||
|
|
are filled with the maximum value.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (tuple of int): the shape of the output tensor
|
|||
|
|
stride (tuple of int): the strides of the output tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.empty_strided((2, 3), (1, 2))
|
|||
|
|
>>> a
|
|||
|
|
tensor([[8.9683e-44, 4.4842e-44, 5.1239e+07],
|
|||
|
|
[0.0000e+00, 0.0000e+00, 3.0705e-41]])
|
|||
|
|
>>> a.stride()
|
|||
|
|
(1, 2)
|
|||
|
|
>>> a.size()
|
|||
|
|
torch.Size([2, 3])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def eq(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
eq(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes element-wise equality
|
|||
|
|
|
|||
|
|
The second argument can be a number or a tensor whose shape is
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with the first argument.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to compare
|
|||
|
|
other (Tensor or float): the tensor or value to compare
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A boolean tensor that is True where :attr:`input` is equal to :attr:`other` and False elsewhere
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.eq(torch.tensor([[1, 2], [3, 4]]), torch.tensor([[1, 1], [4, 4]]))
|
|||
|
|
tensor([[ True, False],
|
|||
|
|
[False, True]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def eq(input: Tensor, other: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
eq(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes element-wise equality
|
|||
|
|
|
|||
|
|
The second argument can be a number or a tensor whose shape is
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with the first argument.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to compare
|
|||
|
|
other (Tensor or float): the tensor or value to compare
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A boolean tensor that is True where :attr:`input` is equal to :attr:`other` and False elsewhere
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.eq(torch.tensor([[1, 2], [3, 4]]), torch.tensor([[1, 1], [4, 4]]))
|
|||
|
|
tensor([[ True, False],
|
|||
|
|
[False, True]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def equal(input: Tensor, other: Tensor) -> _bool:
|
|||
|
|
r"""
|
|||
|
|
equal(input, other) -> bool
|
|||
|
|
|
|||
|
|
``True`` if two tensors have the same size and elements, ``False`` otherwise.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.equal(torch.tensor([1, 2]), torch.tensor([1, 2]))
|
|||
|
|
True
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def erf(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
erf(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.special.erf`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def erf_(input: Tensor) -> Tensor: ...
|
|||
|
|
def erfc(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
erfc(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.special.erfc`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def erfc_(input: Tensor) -> Tensor: ...
|
|||
|
|
def erfinv(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
erfinv(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.special.erfinv`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def exp(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
exp(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the exponential of the elements
|
|||
|
|
of the input tensor :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
y_{i} = e^{x_{i}}
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.exp(torch.tensor([0, math.log(2.)]))
|
|||
|
|
tensor([ 1., 2.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def exp2(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
exp2(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.special.exp2`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def exp2_(input: Tensor) -> Tensor: ...
|
|||
|
|
def exp_(input: Tensor) -> Tensor: ...
|
|||
|
|
def expand_copy(input: Tensor, size: Sequence[Union[_int, SymInt]], *, implicit: _bool = False, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.expand`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def expm1(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
expm1(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.special.expm1`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def expm1_(input: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def eye(n: Union[_int, SymInt], *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
eye(n, m=None, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a 2-D tensor with ones on the diagonal and zeros elsewhere.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
n (int): the number of rows
|
|||
|
|
m (int, optional): the number of columns with default being :attr:`n`
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A 2-D tensor with ones on the diagonal and zeros elsewhere
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.eye(3)
|
|||
|
|
tensor([[ 1., 0., 0.],
|
|||
|
|
[ 0., 1., 0.],
|
|||
|
|
[ 0., 0., 1.]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def eye(n: Union[_int, SymInt], m: Union[_int, SymInt], *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
eye(n, m=None, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a 2-D tensor with ones on the diagonal and zeros elsewhere.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
n (int): the number of rows
|
|||
|
|
m (int, optional): the number of columns with default being :attr:`n`
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A 2-D tensor with ones on the diagonal and zeros elsewhere
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.eye(3)
|
|||
|
|
tensor([[ 1., 0., 0.],
|
|||
|
|
[ 0., 1., 0.],
|
|||
|
|
[ 0., 0., 1.]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def fake_quantize_per_channel_affine(input: Tensor, scale: Tensor, zero_point: Tensor, axis: _int, quant_min: _int, quant_max: _int) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
fake_quantize_per_channel_affine(input, scale, zero_point, axis, quant_min, quant_max) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the data in :attr:`input` fake quantized per channel using :attr:`scale`,
|
|||
|
|
:attr:`zero_point`, :attr:`quant_min` and :attr:`quant_max`, across the channel specified by :attr:`axis`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{output} = (
|
|||
|
|
min(
|
|||
|
|
\text{quant\_max},
|
|||
|
|
max(
|
|||
|
|
\text{quant\_min},
|
|||
|
|
\text{std::nearby\_int}(\text{input} / \text{scale}) + \text{zero\_point}
|
|||
|
|
)
|
|||
|
|
) - \text{zero\_point}
|
|||
|
|
) \times \text{scale}
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input value(s), in ``torch.float32``
|
|||
|
|
scale (Tensor): quantization scale, per channel in ``torch.float32``
|
|||
|
|
zero_point (Tensor): quantization zero_point, per channel in ``torch.int32`` or ``torch.half`` or ``torch.float32``
|
|||
|
|
axis (int32): channel axis
|
|||
|
|
quant_min (int64): lower bound of the quantized domain
|
|||
|
|
quant_max (int64): upper bound of the quantized domain
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A newly fake_quantized per channel ``torch.float32`` tensor
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(2, 2, 2)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[[-0.2525, -0.0466],
|
|||
|
|
[ 0.3491, -0.2168]],
|
|||
|
|
|
|||
|
|
[[-0.5906, 1.6258],
|
|||
|
|
[ 0.6444, -0.0542]]])
|
|||
|
|
>>> scales = (torch.randn(2) + 1) * 0.05
|
|||
|
|
>>> scales
|
|||
|
|
tensor([0.0475, 0.0486])
|
|||
|
|
>>> zero_points = torch.zeros(2).to(torch.int32)
|
|||
|
|
>>> zero_points
|
|||
|
|
tensor([0, 0])
|
|||
|
|
>>> torch.fake_quantize_per_channel_affine(x, scales, zero_points, 1, 0, 255)
|
|||
|
|
tensor([[[0.0000, 0.0000],
|
|||
|
|
[0.3405, 0.0000]],
|
|||
|
|
|
|||
|
|
[[0.0000, 1.6134],
|
|||
|
|
[0.6323, 0.0000]]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def fake_quantize_per_tensor_affine(input: Tensor, scale: _float, zero_point: _int, quant_min: _int, quant_max: _int) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
fake_quantize_per_tensor_affine(input, scale, zero_point, quant_min, quant_max) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the data in :attr:`input` fake quantized using :attr:`scale`,
|
|||
|
|
:attr:`zero_point`, :attr:`quant_min` and :attr:`quant_max`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{output} = (
|
|||
|
|
min(
|
|||
|
|
\text{quant\_max},
|
|||
|
|
max(
|
|||
|
|
\text{quant\_min},
|
|||
|
|
\text{std::nearby\_int}(\text{input} / \text{scale}) + \text{zero\_point}
|
|||
|
|
)
|
|||
|
|
) - \text{zero\_point}
|
|||
|
|
) \times \text{scale}
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input value(s), ``torch.float32`` tensor
|
|||
|
|
scale (double scalar or ``float32`` Tensor): quantization scale
|
|||
|
|
zero_point (int64 scalar or ``int32`` Tensor): quantization zero_point
|
|||
|
|
quant_min (int64): lower bound of the quantized domain
|
|||
|
|
quant_max (int64): upper bound of the quantized domain
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A newly fake_quantized ``torch.float32`` tensor
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(4)
|
|||
|
|
>>> x
|
|||
|
|
tensor([ 0.0552, 0.9730, 0.3973, -1.0780])
|
|||
|
|
>>> torch.fake_quantize_per_tensor_affine(x, 0.1, 0, 0, 255)
|
|||
|
|
tensor([0.1000, 1.0000, 0.4000, 0.0000])
|
|||
|
|
>>> torch.fake_quantize_per_tensor_affine(x, torch.tensor(0.1), torch.tensor(0), 0, 255)
|
|||
|
|
tensor([0.1000, 1.0000, 0.4000, 0.0000])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def fake_quantize_per_tensor_affine(input: Tensor, scale: Tensor, zero_point: Tensor, quant_min: _int, quant_max: _int) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
fake_quantize_per_tensor_affine(input, scale, zero_point, quant_min, quant_max) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the data in :attr:`input` fake quantized using :attr:`scale`,
|
|||
|
|
:attr:`zero_point`, :attr:`quant_min` and :attr:`quant_max`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{output} = (
|
|||
|
|
min(
|
|||
|
|
\text{quant\_max},
|
|||
|
|
max(
|
|||
|
|
\text{quant\_min},
|
|||
|
|
\text{std::nearby\_int}(\text{input} / \text{scale}) + \text{zero\_point}
|
|||
|
|
)
|
|||
|
|
) - \text{zero\_point}
|
|||
|
|
) \times \text{scale}
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input value(s), ``torch.float32`` tensor
|
|||
|
|
scale (double scalar or ``float32`` Tensor): quantization scale
|
|||
|
|
zero_point (int64 scalar or ``int32`` Tensor): quantization zero_point
|
|||
|
|
quant_min (int64): lower bound of the quantized domain
|
|||
|
|
quant_max (int64): upper bound of the quantized domain
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A newly fake_quantized ``torch.float32`` tensor
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(4)
|
|||
|
|
>>> x
|
|||
|
|
tensor([ 0.0552, 0.9730, 0.3973, -1.0780])
|
|||
|
|
>>> torch.fake_quantize_per_tensor_affine(x, 0.1, 0, 0, 255)
|
|||
|
|
tensor([0.1000, 1.0000, 0.4000, 0.0000])
|
|||
|
|
>>> torch.fake_quantize_per_tensor_affine(x, torch.tensor(0.1), torch.tensor(0), 0, 255)
|
|||
|
|
tensor([0.1000, 1.0000, 0.4000, 0.0000])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def fbgemm_linear_fp16_weight(input: Tensor, packed_weight: Tensor, bias: Tensor) -> Tensor: ...
|
|||
|
|
def fbgemm_linear_fp16_weight_fp32_activation(input: Tensor, packed_weight: Tensor, bias: Tensor) -> Tensor: ...
|
|||
|
|
def fbgemm_linear_int8_weight(input: Tensor, weight: Tensor, packed: Tensor, col_offsets: Tensor, weight_scale: Union[Number, _complex], weight_zero_point: Union[Number, _complex], bias: Tensor) -> Tensor: ...
|
|||
|
|
def fbgemm_linear_int8_weight_fp32_activation(input: Tensor, weight: Tensor, packed: Tensor, col_offsets: Tensor, weight_scale: Union[Number, _complex], weight_zero_point: Union[Number, _complex], bias: Tensor) -> Tensor: ...
|
|||
|
|
def fbgemm_linear_quantize_weight(input: Tensor) -> Tuple[Tensor, Tensor, _float, _int]: ...
|
|||
|
|
def fbgemm_pack_gemm_matrix_fp16(input: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def fbgemm_pack_quantized_matrix(input: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def fbgemm_pack_quantized_matrix(input: Tensor, K: _int, N: _int) -> Tensor: ...
|
|||
|
|
def feature_alpha_dropout(input: Tensor, p: _float, train: _bool) -> Tensor: ...
|
|||
|
|
def feature_alpha_dropout_(input: Tensor, p: _float, train: _bool) -> Tensor: ...
|
|||
|
|
def feature_dropout(input: Tensor, p: _float, train: _bool) -> Tensor: ...
|
|||
|
|
def feature_dropout_(input: Tensor, p: _float, train: _bool) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def fill(input: Tensor, value: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def fill(input: Tensor, value: Union[Number, _complex]) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def fill_(input: Tensor, value: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def fill_(input: Tensor, value: Union[Number, _complex]) -> Tensor: ...
|
|||
|
|
def fix(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
fix(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.trunc`
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def fix_(input: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def flatten(input: Tensor, start_dim: _int = 0, end_dim: _int = -1) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
flatten(input, start_dim=0, end_dim=-1) -> Tensor
|
|||
|
|
|
|||
|
|
Flattens :attr:`input` by reshaping it into a one-dimensional tensor. If :attr:`start_dim` or :attr:`end_dim`
|
|||
|
|
are passed, only dimensions starting with :attr:`start_dim` and ending with :attr:`end_dim` are flattened.
|
|||
|
|
The order of elements in :attr:`input` is unchanged.
|
|||
|
|
|
|||
|
|
Unlike NumPy's flatten, which always copies input's data, this function may return the original object, a view,
|
|||
|
|
or copy. If no dimensions are flattened, then the original object :attr:`input` is returned. Otherwise, if input can
|
|||
|
|
be viewed as the flattened shape, then that view is returned. Finally, only if the input cannot be viewed as the
|
|||
|
|
flattened shape is input's data copied. See :meth:`torch.Tensor.view` for details on when a view will be returned.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
Flattening a zero-dimensional tensor will return a one-dimensional view.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
start_dim (int): the first dim to flatten
|
|||
|
|
end_dim (int): the last dim to flatten
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> t = torch.tensor([[[1, 2],
|
|||
|
|
... [3, 4]],
|
|||
|
|
... [[5, 6],
|
|||
|
|
... [7, 8]]])
|
|||
|
|
>>> torch.flatten(t)
|
|||
|
|
tensor([1, 2, 3, 4, 5, 6, 7, 8])
|
|||
|
|
>>> torch.flatten(t, start_dim=1)
|
|||
|
|
tensor([[1, 2, 3, 4],
|
|||
|
|
[5, 6, 7, 8]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def flatten(input: Tensor, start_dim: _int, end_dim: _int, out_dim: Union[str, ellipsis, None]) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
flatten(input, start_dim=0, end_dim=-1) -> Tensor
|
|||
|
|
|
|||
|
|
Flattens :attr:`input` by reshaping it into a one-dimensional tensor. If :attr:`start_dim` or :attr:`end_dim`
|
|||
|
|
are passed, only dimensions starting with :attr:`start_dim` and ending with :attr:`end_dim` are flattened.
|
|||
|
|
The order of elements in :attr:`input` is unchanged.
|
|||
|
|
|
|||
|
|
Unlike NumPy's flatten, which always copies input's data, this function may return the original object, a view,
|
|||
|
|
or copy. If no dimensions are flattened, then the original object :attr:`input` is returned. Otherwise, if input can
|
|||
|
|
be viewed as the flattened shape, then that view is returned. Finally, only if the input cannot be viewed as the
|
|||
|
|
flattened shape is input's data copied. See :meth:`torch.Tensor.view` for details on when a view will be returned.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
Flattening a zero-dimensional tensor will return a one-dimensional view.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
start_dim (int): the first dim to flatten
|
|||
|
|
end_dim (int): the last dim to flatten
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> t = torch.tensor([[[1, 2],
|
|||
|
|
... [3, 4]],
|
|||
|
|
... [[5, 6],
|
|||
|
|
... [7, 8]]])
|
|||
|
|
>>> torch.flatten(t)
|
|||
|
|
tensor([1, 2, 3, 4, 5, 6, 7, 8])
|
|||
|
|
>>> torch.flatten(t, start_dim=1)
|
|||
|
|
tensor([[1, 2, 3, 4],
|
|||
|
|
[5, 6, 7, 8]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def flatten(input: Tensor, start_dim: Union[str, ellipsis, None], end_dim: Union[str, ellipsis, None], out_dim: Union[str, ellipsis, None]) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
flatten(input, start_dim=0, end_dim=-1) -> Tensor
|
|||
|
|
|
|||
|
|
Flattens :attr:`input` by reshaping it into a one-dimensional tensor. If :attr:`start_dim` or :attr:`end_dim`
|
|||
|
|
are passed, only dimensions starting with :attr:`start_dim` and ending with :attr:`end_dim` are flattened.
|
|||
|
|
The order of elements in :attr:`input` is unchanged.
|
|||
|
|
|
|||
|
|
Unlike NumPy's flatten, which always copies input's data, this function may return the original object, a view,
|
|||
|
|
or copy. If no dimensions are flattened, then the original object :attr:`input` is returned. Otherwise, if input can
|
|||
|
|
be viewed as the flattened shape, then that view is returned. Finally, only if the input cannot be viewed as the
|
|||
|
|
flattened shape is input's data copied. See :meth:`torch.Tensor.view` for details on when a view will be returned.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
Flattening a zero-dimensional tensor will return a one-dimensional view.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
start_dim (int): the first dim to flatten
|
|||
|
|
end_dim (int): the last dim to flatten
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> t = torch.tensor([[[1, 2],
|
|||
|
|
... [3, 4]],
|
|||
|
|
... [[5, 6],
|
|||
|
|
... [7, 8]]])
|
|||
|
|
>>> torch.flatten(t)
|
|||
|
|
tensor([1, 2, 3, 4, 5, 6, 7, 8])
|
|||
|
|
>>> torch.flatten(t, start_dim=1)
|
|||
|
|
tensor([[1, 2, 3, 4],
|
|||
|
|
[5, 6, 7, 8]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def flatten(input: Tensor, dims: Sequence[Union[str, ellipsis, None]], out_dim: Union[str, ellipsis, None]) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
flatten(input, start_dim=0, end_dim=-1) -> Tensor
|
|||
|
|
|
|||
|
|
Flattens :attr:`input` by reshaping it into a one-dimensional tensor. If :attr:`start_dim` or :attr:`end_dim`
|
|||
|
|
are passed, only dimensions starting with :attr:`start_dim` and ending with :attr:`end_dim` are flattened.
|
|||
|
|
The order of elements in :attr:`input` is unchanged.
|
|||
|
|
|
|||
|
|
Unlike NumPy's flatten, which always copies input's data, this function may return the original object, a view,
|
|||
|
|
or copy. If no dimensions are flattened, then the original object :attr:`input` is returned. Otherwise, if input can
|
|||
|
|
be viewed as the flattened shape, then that view is returned. Finally, only if the input cannot be viewed as the
|
|||
|
|
flattened shape is input's data copied. See :meth:`torch.Tensor.view` for details on when a view will be returned.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
Flattening a zero-dimensional tensor will return a one-dimensional view.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
start_dim (int): the first dim to flatten
|
|||
|
|
end_dim (int): the last dim to flatten
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> t = torch.tensor([[[1, 2],
|
|||
|
|
... [3, 4]],
|
|||
|
|
... [[5, 6],
|
|||
|
|
... [7, 8]]])
|
|||
|
|
>>> torch.flatten(t)
|
|||
|
|
tensor([1, 2, 3, 4, 5, 6, 7, 8])
|
|||
|
|
>>> torch.flatten(t, start_dim=1)
|
|||
|
|
tensor([[1, 2, 3, 4],
|
|||
|
|
[5, 6, 7, 8]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def flip(input: Tensor, dims: _size) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
flip(input, dims) -> Tensor
|
|||
|
|
|
|||
|
|
Reverse the order of an n-D tensor along given axis in dims.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
`torch.flip` makes a copy of :attr:`input`'s data. This is different from NumPy's `np.flip`,
|
|||
|
|
which returns a view in constant time. Since copying a tensor's data is more work than viewing that data,
|
|||
|
|
`torch.flip` is expected to be slower than `np.flip`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dims (a list or tuple): axis to flip on
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.arange(8).view(2, 2, 2)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[[ 0, 1],
|
|||
|
|
[ 2, 3]],
|
|||
|
|
|
|||
|
|
[[ 4, 5],
|
|||
|
|
[ 6, 7]]])
|
|||
|
|
>>> torch.flip(x, [0, 1])
|
|||
|
|
tensor([[[ 6, 7],
|
|||
|
|
[ 4, 5]],
|
|||
|
|
|
|||
|
|
[[ 2, 3],
|
|||
|
|
[ 0, 1]]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def fliplr(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
fliplr(input) -> Tensor
|
|||
|
|
|
|||
|
|
Flip tensor in the left/right direction, returning a new tensor.
|
|||
|
|
|
|||
|
|
Flip the entries in each row in the left/right direction.
|
|||
|
|
Columns are preserved, but appear in a different order than before.
|
|||
|
|
|
|||
|
|
Note:
|
|||
|
|
Requires the tensor to be at least 2-D.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
`torch.fliplr` makes a copy of :attr:`input`'s data. This is different from NumPy's `np.fliplr`,
|
|||
|
|
which returns a view in constant time. Since copying a tensor's data is more work than viewing that data,
|
|||
|
|
`torch.fliplr` is expected to be slower than `np.fliplr`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): Must be at least 2-dimensional.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.arange(4).view(2, 2)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[0, 1],
|
|||
|
|
[2, 3]])
|
|||
|
|
>>> torch.fliplr(x)
|
|||
|
|
tensor([[1, 0],
|
|||
|
|
[3, 2]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def flipud(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
flipud(input) -> Tensor
|
|||
|
|
|
|||
|
|
Flip tensor in the up/down direction, returning a new tensor.
|
|||
|
|
|
|||
|
|
Flip the entries in each column in the up/down direction.
|
|||
|
|
Rows are preserved, but appear in a different order than before.
|
|||
|
|
|
|||
|
|
Note:
|
|||
|
|
Requires the tensor to be at least 1-D.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
`torch.flipud` makes a copy of :attr:`input`'s data. This is different from NumPy's `np.flipud`,
|
|||
|
|
which returns a view in constant time. Since copying a tensor's data is more work than viewing that data,
|
|||
|
|
`torch.flipud` is expected to be slower than `np.flipud`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): Must be at least 1-dimensional.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.arange(4).view(2, 2)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[0, 1],
|
|||
|
|
[2, 3]])
|
|||
|
|
>>> torch.flipud(x)
|
|||
|
|
tensor([[2, 3],
|
|||
|
|
[0, 1]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def float_power(input: Tensor, exponent: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
float_power(input, exponent, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Raises :attr:`input` to the power of :attr:`exponent`, elementwise, in double precision.
|
|||
|
|
If neither input is complex returns a ``torch.float64`` tensor,
|
|||
|
|
and if one or more inputs is complex returns a ``torch.complex128`` tensor.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
This function always computes in double precision, unlike :func:`torch.pow`,
|
|||
|
|
which implements more typical :ref:`type promotion <type-promotion-doc>`.
|
|||
|
|
This is useful when the computation needs to be performed in a wider or more precise dtype,
|
|||
|
|
or the results of the computation may contain fractional values not representable in the input dtypes,
|
|||
|
|
like when an integer base is raised to a negative integer exponent.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor or Number): the base value(s)
|
|||
|
|
exponent (Tensor or Number): the exponent value(s)
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randint(10, (4,))
|
|||
|
|
>>> a
|
|||
|
|
tensor([6, 4, 7, 1])
|
|||
|
|
>>> torch.float_power(a, 2)
|
|||
|
|
tensor([36., 16., 49., 1.], dtype=torch.float64)
|
|||
|
|
|
|||
|
|
>>> a = torch.arange(1, 5)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 1, 2, 3, 4])
|
|||
|
|
>>> exp = torch.tensor([2, -3, 4, -5])
|
|||
|
|
>>> exp
|
|||
|
|
tensor([ 2, -3, 4, -5])
|
|||
|
|
>>> torch.float_power(a, exp)
|
|||
|
|
tensor([1.0000e+00, 1.2500e-01, 8.1000e+01, 9.7656e-04], dtype=torch.float64)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def float_power(self: Union[Number, _complex], exponent: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
float_power(input, exponent, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Raises :attr:`input` to the power of :attr:`exponent`, elementwise, in double precision.
|
|||
|
|
If neither input is complex returns a ``torch.float64`` tensor,
|
|||
|
|
and if one or more inputs is complex returns a ``torch.complex128`` tensor.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
This function always computes in double precision, unlike :func:`torch.pow`,
|
|||
|
|
which implements more typical :ref:`type promotion <type-promotion-doc>`.
|
|||
|
|
This is useful when the computation needs to be performed in a wider or more precise dtype,
|
|||
|
|
or the results of the computation may contain fractional values not representable in the input dtypes,
|
|||
|
|
like when an integer base is raised to a negative integer exponent.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor or Number): the base value(s)
|
|||
|
|
exponent (Tensor or Number): the exponent value(s)
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randint(10, (4,))
|
|||
|
|
>>> a
|
|||
|
|
tensor([6, 4, 7, 1])
|
|||
|
|
>>> torch.float_power(a, 2)
|
|||
|
|
tensor([36., 16., 49., 1.], dtype=torch.float64)
|
|||
|
|
|
|||
|
|
>>> a = torch.arange(1, 5)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 1, 2, 3, 4])
|
|||
|
|
>>> exp = torch.tensor([2, -3, 4, -5])
|
|||
|
|
>>> exp
|
|||
|
|
tensor([ 2, -3, 4, -5])
|
|||
|
|
>>> torch.float_power(a, exp)
|
|||
|
|
tensor([1.0000e+00, 1.2500e-01, 8.1000e+01, 9.7656e-04], dtype=torch.float64)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def float_power(input: Tensor, exponent: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
float_power(input, exponent, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Raises :attr:`input` to the power of :attr:`exponent`, elementwise, in double precision.
|
|||
|
|
If neither input is complex returns a ``torch.float64`` tensor,
|
|||
|
|
and if one or more inputs is complex returns a ``torch.complex128`` tensor.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
This function always computes in double precision, unlike :func:`torch.pow`,
|
|||
|
|
which implements more typical :ref:`type promotion <type-promotion-doc>`.
|
|||
|
|
This is useful when the computation needs to be performed in a wider or more precise dtype,
|
|||
|
|
or the results of the computation may contain fractional values not representable in the input dtypes,
|
|||
|
|
like when an integer base is raised to a negative integer exponent.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor or Number): the base value(s)
|
|||
|
|
exponent (Tensor or Number): the exponent value(s)
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randint(10, (4,))
|
|||
|
|
>>> a
|
|||
|
|
tensor([6, 4, 7, 1])
|
|||
|
|
>>> torch.float_power(a, 2)
|
|||
|
|
tensor([36., 16., 49., 1.], dtype=torch.float64)
|
|||
|
|
|
|||
|
|
>>> a = torch.arange(1, 5)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 1, 2, 3, 4])
|
|||
|
|
>>> exp = torch.tensor([2, -3, 4, -5])
|
|||
|
|
>>> exp
|
|||
|
|
tensor([ 2, -3, 4, -5])
|
|||
|
|
>>> torch.float_power(a, exp)
|
|||
|
|
tensor([1.0000e+00, 1.2500e-01, 8.1000e+01, 9.7656e-04], dtype=torch.float64)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def floor(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
floor(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the floor of the elements of :attr:`input`,
|
|||
|
|
the largest integer less than or equal to each element.
|
|||
|
|
|
|||
|
|
For integer inputs, follows the array-api convention of returning a
|
|||
|
|
copy of the input tensor.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \left\lfloor \text{input}_{i} \right\rfloor
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([-0.8166, 1.5308, -0.2530, -0.2091])
|
|||
|
|
>>> torch.floor(a)
|
|||
|
|
tensor([-1., 1., -1., -1.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def floor_(input: Tensor) -> Tensor: ...
|
|||
|
|
def floor_divide(input: Union[Tensor, Number], other: Union[Tensor, Number], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
floor_divide(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
Before PyTorch 1.13 :func:`torch.floor_divide` incorrectly performed
|
|||
|
|
truncation division. To restore the previous behavior use
|
|||
|
|
:func:`torch.div` with ``rounding_mode='trunc'``.
|
|||
|
|
|
|||
|
|
Computes :attr:`input` divided by :attr:`other`, elementwise, and floors
|
|||
|
|
the result.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{{out}}_i = \text{floor} \left( \frac{{\text{{input}}_i}}{{\text{{other}}_i}} \right)
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
Supports broadcasting to a common shape, type promotion, and integer and float inputs.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor or Number): the dividend
|
|||
|
|
other (Tensor or Number): the divisor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([4.0, 3.0])
|
|||
|
|
>>> b = torch.tensor([2.0, 2.0])
|
|||
|
|
>>> torch.floor_divide(a, b)
|
|||
|
|
tensor([2.0, 1.0])
|
|||
|
|
>>> torch.floor_divide(a, 1.4)
|
|||
|
|
tensor([2.0, 2.0])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def fmax(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
fmax(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the element-wise maximum of :attr:`input` and :attr:`other`.
|
|||
|
|
|
|||
|
|
This is like :func:`torch.maximum` except it handles NaNs differently:
|
|||
|
|
if exactly one of the two elements being compared is a NaN then the non-NaN element is taken as the maximum.
|
|||
|
|
Only if both elements are NaN is NaN propagated.
|
|||
|
|
|
|||
|
|
This function is a wrapper around C++'s ``std::fmax`` and is similar to NumPy's ``fmax`` function.
|
|||
|
|
|
|||
|
|
Supports :ref:`broadcasting to a common shape <broadcasting-semantics>`,
|
|||
|
|
:ref:`type promotion <type-promotion-doc>`, and integer and floating-point inputs.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
other (Tensor): the second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([9.7, float('nan'), 3.1, float('nan')])
|
|||
|
|
>>> b = torch.tensor([-2.2, 0.5, float('nan'), float('nan')])
|
|||
|
|
>>> torch.fmax(a, b)
|
|||
|
|
tensor([9.7000, 0.5000, 3.1000, nan])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def fmin(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
fmin(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the element-wise minimum of :attr:`input` and :attr:`other`.
|
|||
|
|
|
|||
|
|
This is like :func:`torch.minimum` except it handles NaNs differently:
|
|||
|
|
if exactly one of the two elements being compared is a NaN then the non-NaN element is taken as the minimum.
|
|||
|
|
Only if both elements are NaN is NaN propagated.
|
|||
|
|
|
|||
|
|
This function is a wrapper around C++'s ``std::fmin`` and is similar to NumPy's ``fmin`` function.
|
|||
|
|
|
|||
|
|
Supports :ref:`broadcasting to a common shape <broadcasting-semantics>`,
|
|||
|
|
:ref:`type promotion <type-promotion-doc>`, and integer and floating-point inputs.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
other (Tensor): the second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([2.2, float('nan'), 2.1, float('nan')])
|
|||
|
|
>>> b = torch.tensor([-9.3, 0.1, float('nan'), float('nan')])
|
|||
|
|
>>> torch.fmin(a, b)
|
|||
|
|
tensor([-9.3000, 0.1000, 2.1000, nan])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def fmod(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
fmod(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Applies C++'s `std::fmod <https://en.cppreference.com/w/cpp/numeric/math/fmod>`_ entrywise.
|
|||
|
|
The result has the same sign as the dividend :attr:`input` and its absolute value
|
|||
|
|
is less than that of :attr:`other`.
|
|||
|
|
|
|||
|
|
This function may be defined in terms of :func:`torch.div` as
|
|||
|
|
|
|||
|
|
.. code:: python
|
|||
|
|
|
|||
|
|
torch.fmod(a, b) == a - a.div(b, rounding_mode="trunc") * b
|
|||
|
|
|
|||
|
|
Supports :ref:`broadcasting to a common shape <broadcasting-semantics>`,
|
|||
|
|
:ref:`type promotion <type-promotion-doc>`, and integer and float inputs.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
When the divisor is zero, returns ``NaN`` for floating point dtypes
|
|||
|
|
on both CPU and GPU; raises ``RuntimeError`` for integer division by
|
|||
|
|
zero on CPU; Integer division by zero on GPU may return any value.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
Complex inputs are not supported. In some cases, it is not mathematically
|
|||
|
|
possible to satisfy the definition of a modulo operation with complex numbers.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.remainder` which implements Python's modulus operator.
|
|||
|
|
This one is defined using division rounding down the result.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the dividend
|
|||
|
|
other (Tensor or Scalar): the divisor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.fmod(torch.tensor([-3., -2, -1, 1, 2, 3]), 2)
|
|||
|
|
tensor([-1., -0., -1., 1., 0., 1.])
|
|||
|
|
>>> torch.fmod(torch.tensor([1, 2, 3, 4, 5]), -1.5)
|
|||
|
|
tensor([1.0000, 0.5000, 0.0000, 1.0000, 0.5000])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def fmod(input: Tensor, other: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
fmod(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Applies C++'s `std::fmod <https://en.cppreference.com/w/cpp/numeric/math/fmod>`_ entrywise.
|
|||
|
|
The result has the same sign as the dividend :attr:`input` and its absolute value
|
|||
|
|
is less than that of :attr:`other`.
|
|||
|
|
|
|||
|
|
This function may be defined in terms of :func:`torch.div` as
|
|||
|
|
|
|||
|
|
.. code:: python
|
|||
|
|
|
|||
|
|
torch.fmod(a, b) == a - a.div(b, rounding_mode="trunc") * b
|
|||
|
|
|
|||
|
|
Supports :ref:`broadcasting to a common shape <broadcasting-semantics>`,
|
|||
|
|
:ref:`type promotion <type-promotion-doc>`, and integer and float inputs.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
When the divisor is zero, returns ``NaN`` for floating point dtypes
|
|||
|
|
on both CPU and GPU; raises ``RuntimeError`` for integer division by
|
|||
|
|
zero on CPU; Integer division by zero on GPU may return any value.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
Complex inputs are not supported. In some cases, it is not mathematically
|
|||
|
|
possible to satisfy the definition of a modulo operation with complex numbers.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.remainder` which implements Python's modulus operator.
|
|||
|
|
This one is defined using division rounding down the result.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the dividend
|
|||
|
|
other (Tensor or Scalar): the divisor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.fmod(torch.tensor([-3., -2, -1, 1, 2, 3]), 2)
|
|||
|
|
tensor([-1., -0., -1., 1., 0., 1.])
|
|||
|
|
>>> torch.fmod(torch.tensor([1, 2, 3, 4, 5]), -1.5)
|
|||
|
|
tensor([1.0000, 0.5000, 0.0000, 1.0000, 0.5000])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def frac(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
frac(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the fractional portion of each element in :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \text{input}_{i} - \left\lfloor |\text{input}_{i}| \right\rfloor * \operatorname{sgn}(\text{input}_{i})
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.frac(torch.tensor([1, 2.5, -3.2]))
|
|||
|
|
tensor([ 0.0000, 0.5000, -0.2000])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def frac_(input: Tensor) -> Tensor: ...
|
|||
|
|
def frexp(input: Tensor, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.frexp:
|
|||
|
|
r"""
|
|||
|
|
frexp(input, *, out=None) -> (Tensor mantissa, Tensor exponent)
|
|||
|
|
|
|||
|
|
Decomposes :attr:`input` into mantissa and exponent tensors
|
|||
|
|
such that :math:`\text{input} = \text{mantissa} \times 2^{\text{exponent}}`.
|
|||
|
|
|
|||
|
|
The range of mantissa is the open interval (-1, 1).
|
|||
|
|
|
|||
|
|
Supports float inputs.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor
|
|||
|
|
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the output tensors
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.arange(9.)
|
|||
|
|
>>> mantissa, exponent = torch.frexp(x)
|
|||
|
|
>>> mantissa
|
|||
|
|
tensor([0.0000, 0.5000, 0.5000, 0.7500, 0.5000, 0.6250, 0.7500, 0.8750, 0.5000])
|
|||
|
|
>>> exponent
|
|||
|
|
tensor([0, 1, 2, 2, 3, 3, 3, 3, 4], dtype=torch.int32)
|
|||
|
|
>>> torch.ldexp(mantissa, exponent)
|
|||
|
|
tensor([0., 1., 2., 3., 4., 5., 6., 7., 8.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def frobenius_norm(input: Tensor, dim: Union[_int, _size], keepdim: _bool = False, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def from_file(filename: str, shared: Optional[_bool] = None, size: Optional[_int] = 0, *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
from_file(filename, shared=None, size=0, *, dtype=None, layout=None, device=None, pin_memory=False)
|
|||
|
|
|
|||
|
|
Creates a CPU tensor with a storage backed by a memory-mapped file.
|
|||
|
|
|
|||
|
|
If ``shared`` is True, then memory is shared between processes. All changes are written to the file.
|
|||
|
|
If ``shared`` is False, then changes to the tensor do not affect the file.
|
|||
|
|
|
|||
|
|
``size`` is the number of elements in the Tensor. If ``shared`` is ``False``, then the file must contain
|
|||
|
|
at least ``size * sizeof(dtype)`` bytes. If ``shared`` is ``True`` the file will be created if needed.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
Only CPU tensors can be mapped to files.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
For now, tensors with storages backed by a memory-mapped file cannot be created in pinned memory.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
filename (str): file name to map
|
|||
|
|
shared (bool): whether to share memory (whether ``MAP_SHARED`` or ``MAP_PRIVATE`` is passed to the
|
|||
|
|
underlying `mmap(2) call <https://man7.org/linux/man-pages/man2/mmap.2.html>`_)
|
|||
|
|
size (int): number of elements in the tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
>>> t = torch.randn(2, 5, dtype=torch.float64)
|
|||
|
|
>>> t.numpy().tofile('storage.pt')
|
|||
|
|
>>> t_mapped = torch.from_file('storage.pt', shared=False, size=10, dtype=torch.float64)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def from_numpy(ndarray) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
from_numpy(ndarray) -> Tensor
|
|||
|
|
|
|||
|
|
Creates a :class:`Tensor` from a :class:`numpy.ndarray`.
|
|||
|
|
|
|||
|
|
The returned tensor and :attr:`ndarray` share the same memory. Modifications to
|
|||
|
|
the tensor will be reflected in the :attr:`ndarray` and vice versa. The returned
|
|||
|
|
tensor is not resizable.
|
|||
|
|
|
|||
|
|
It currently accepts :attr:`ndarray` with dtypes of ``numpy.float64``,
|
|||
|
|
``numpy.float32``, ``numpy.float16``, ``numpy.complex64``, ``numpy.complex128``,
|
|||
|
|
``numpy.int64``, ``numpy.int32``, ``numpy.int16``, ``numpy.int8``, ``numpy.uint8``,
|
|||
|
|
and ``bool``.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
Writing to a tensor created from a read-only NumPy array is not supported and will result in undefined behavior.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = numpy.array([1, 2, 3])
|
|||
|
|
>>> t = torch.from_numpy(a)
|
|||
|
|
>>> t
|
|||
|
|
tensor([ 1, 2, 3])
|
|||
|
|
>>> t[0] = -1
|
|||
|
|
>>> a
|
|||
|
|
array([-1, 2, 3])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def frombuffer(buffer: Any, *, dtype: _dtype, count: int = -1, offset: int = 0, requires_grad: _bool = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
frombuffer(buffer, *, dtype, count=-1, offset=0, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Creates a 1-dimensional :class:`Tensor` from an object that implements
|
|||
|
|
the Python buffer protocol.
|
|||
|
|
|
|||
|
|
Skips the first :attr:`offset` bytes in the buffer, and interprets the rest of
|
|||
|
|
the raw bytes as a 1-dimensional tensor of type :attr:`dtype` with :attr:`count`
|
|||
|
|
elements.
|
|||
|
|
|
|||
|
|
Note that either of the following must be true:
|
|||
|
|
|
|||
|
|
1. :attr:`count` is a positive non-zero number, and the total number of bytes
|
|||
|
|
in the buffer is more than :attr:`offset` plus :attr:`count` times the size
|
|||
|
|
(in bytes) of :attr:`dtype`.
|
|||
|
|
|
|||
|
|
2. :attr:`count` is negative, and the length (number of bytes) of the buffer
|
|||
|
|
subtracted by the :attr:`offset` is a multiple of the size (in bytes) of
|
|||
|
|
:attr:`dtype`.
|
|||
|
|
|
|||
|
|
The returned tensor and buffer share the same memory. Modifications to
|
|||
|
|
the tensor will be reflected in the buffer and vice versa. The returned
|
|||
|
|
tensor is not resizable.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
This function increments the reference count for the object that
|
|||
|
|
owns the shared memory. Therefore, such memory will not be deallocated
|
|||
|
|
before the returned tensor goes out of scope.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
This function's behavior is undefined when passed an object implementing
|
|||
|
|
the buffer protocol whose data is not on the CPU. Doing so is likely to
|
|||
|
|
cause a segmentation fault.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
This function does not try to infer the :attr:`dtype` (hence, it is not
|
|||
|
|
optional). Passing a different :attr:`dtype` than its source may result
|
|||
|
|
in unexpected behavior.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
buffer (object): a Python object that exposes the buffer interface.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`): the desired data type of returned tensor.
|
|||
|
|
count (int, optional): the number of desired elements to be read.
|
|||
|
|
If negative, all the elements (until the end of the buffer) will be
|
|||
|
|
read. Default: -1.
|
|||
|
|
offset (int, optional): the number of bytes to skip at the start of
|
|||
|
|
the buffer. Default: 0.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> import array
|
|||
|
|
>>> a = array.array('i', [1, 2, 3])
|
|||
|
|
>>> t = torch.frombuffer(a, dtype=torch.int32)
|
|||
|
|
>>> t
|
|||
|
|
tensor([ 1, 2, 3])
|
|||
|
|
>>> t[0] = -1
|
|||
|
|
>>> a
|
|||
|
|
array([-1, 2, 3])
|
|||
|
|
|
|||
|
|
>>> # Interprets the signed char bytes as 32-bit integers.
|
|||
|
|
>>> # Each 4 signed char elements will be interpreted as
|
|||
|
|
>>> # 1 signed 32-bit integer.
|
|||
|
|
>>> import array
|
|||
|
|
>>> a = array.array('b', [-1, 0, 0, 0])
|
|||
|
|
>>> torch.frombuffer(a, dtype=torch.int32)
|
|||
|
|
tensor([255], dtype=torch.int32)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def full(size: _size, fill_value: Union[Number, _complex], *, out: Optional[Tensor] = None, layout: _layout = strided, dtype: Optional[_dtype] = None, device: Optional[DeviceLikeType] = None, requires_grad: _bool = False, pin_memory: _bool = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
full(size, fill_value, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Creates a tensor of size :attr:`size` filled with :attr:`fill_value`. The
|
|||
|
|
tensor's dtype is inferred from :attr:`fill_value`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a list, tuple, or :class:`torch.Size` of integers defining the
|
|||
|
|
shape of the output tensor.
|
|||
|
|
fill_value (Scalar): the value to fill the output tensor with.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.full((2, 3), 3.141592)
|
|||
|
|
tensor([[ 3.1416, 3.1416, 3.1416],
|
|||
|
|
[ 3.1416, 3.1416, 3.1416]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def full(size: _size, fill_value: Union[Number, _complex], *, names: List[Union[str, None]], layout: _layout = strided, dtype: Optional[_dtype] = None, device: Optional[DeviceLikeType] = None, requires_grad: _bool = False, pin_memory: _bool = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
full(size, fill_value, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Creates a tensor of size :attr:`size` filled with :attr:`fill_value`. The
|
|||
|
|
tensor's dtype is inferred from :attr:`fill_value`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a list, tuple, or :class:`torch.Size` of integers defining the
|
|||
|
|
shape of the output tensor.
|
|||
|
|
fill_value (Scalar): the value to fill the output tensor with.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.full((2, 3), 3.141592)
|
|||
|
|
tensor([[ 3.1416, 3.1416, 3.1416],
|
|||
|
|
[ 3.1416, 3.1416, 3.1416]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def full(size: Sequence[Union[_int, SymInt]], fill_value: Union[Number, _complex], *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
full(size, fill_value, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Creates a tensor of size :attr:`size` filled with :attr:`fill_value`. The
|
|||
|
|
tensor's dtype is inferred from :attr:`fill_value`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a list, tuple, or :class:`torch.Size` of integers defining the
|
|||
|
|
shape of the output tensor.
|
|||
|
|
fill_value (Scalar): the value to fill the output tensor with.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.full((2, 3), 3.141592)
|
|||
|
|
tensor([[ 3.1416, 3.1416, 3.1416],
|
|||
|
|
[ 3.1416, 3.1416, 3.1416]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def full(size: _size, fill_value: Union[Number, _complex], *, names: Optional[Sequence[Union[str, ellipsis, None]]], dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
full(size, fill_value, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Creates a tensor of size :attr:`size` filled with :attr:`fill_value`. The
|
|||
|
|
tensor's dtype is inferred from :attr:`fill_value`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a list, tuple, or :class:`torch.Size` of integers defining the
|
|||
|
|
shape of the output tensor.
|
|||
|
|
fill_value (Scalar): the value to fill the output tensor with.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.full((2, 3), 3.141592)
|
|||
|
|
tensor([[ 3.1416, 3.1416, 3.1416],
|
|||
|
|
[ 3.1416, 3.1416, 3.1416]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def full_like(input: Tensor, fill_value: Union[Number, _complex], *, memory_format: Optional[memory_format] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
full_like(input, fill_value, \*, dtype=None, layout=torch.strided, device=None, requires_grad=False, memory_format=torch.preserve_format) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor with the same size as :attr:`input` filled with :attr:`fill_value`.
|
|||
|
|
``torch.full_like(input, fill_value)`` is equivalent to
|
|||
|
|
``torch.full(input.size(), fill_value, dtype=input.dtype, layout=input.layout, device=input.device)``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the size of :attr:`input` will determine size of the output tensor.
|
|||
|
|
fill_value: the number to fill the output tensor with.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned Tensor.
|
|||
|
|
Default: if ``None``, defaults to the dtype of :attr:`input`.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned tensor.
|
|||
|
|
Default: if ``None``, defaults to the layout of :attr:`input`.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, defaults to the device of :attr:`input`.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
memory_format (:class:`torch.memory_format`, optional): the desired memory format of
|
|||
|
|
returned Tensor. Default: ``torch.preserve_format``.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def fused_moving_avg_obs_fake_quant(input: Tensor, observer_on: Tensor, fake_quant_on: Tensor, running_min: Tensor, running_max: Tensor, scale: Tensor, zero_point: Tensor, averaging_const: _float, quant_min: _int, quant_max: _int, ch_axis: _int, per_row_fake_quant: _bool = False, symmetric_quant: _bool = False) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def gather(input: Tensor, dim: _int, index: Tensor, *, sparse_grad: _bool = False, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
gather(input, dim, index, *, sparse_grad=False, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Gathers values along an axis specified by `dim`.
|
|||
|
|
|
|||
|
|
For a 3-D tensor the output is specified by::
|
|||
|
|
|
|||
|
|
out[i][j][k] = input[index[i][j][k]][j][k] # if dim == 0
|
|||
|
|
out[i][j][k] = input[i][index[i][j][k]][k] # if dim == 1
|
|||
|
|
out[i][j][k] = input[i][j][index[i][j][k]] # if dim == 2
|
|||
|
|
|
|||
|
|
:attr:`input` and :attr:`index` must have the same number of dimensions.
|
|||
|
|
It is also required that ``index.size(d) <= input.size(d)`` for all
|
|||
|
|
dimensions ``d != dim``. :attr:`out` will have the same shape as :attr:`index`.
|
|||
|
|
Note that ``input`` and ``index`` do not broadcast against each other.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the source tensor
|
|||
|
|
dim (int): the axis along which to index
|
|||
|
|
index (LongTensor): the indices of elements to gather
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
sparse_grad (bool, optional): If ``True``, gradient w.r.t. :attr:`input` will be a sparse tensor.
|
|||
|
|
out (Tensor, optional): the destination tensor
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> t = torch.tensor([[1, 2], [3, 4]])
|
|||
|
|
>>> torch.gather(t, 1, torch.tensor([[0, 0], [1, 0]]))
|
|||
|
|
tensor([[ 1, 1],
|
|||
|
|
[ 4, 3]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def gather(input: Tensor, dim: Union[str, ellipsis, None], index: Tensor, *, sparse_grad: _bool = False, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
gather(input, dim, index, *, sparse_grad=False, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Gathers values along an axis specified by `dim`.
|
|||
|
|
|
|||
|
|
For a 3-D tensor the output is specified by::
|
|||
|
|
|
|||
|
|
out[i][j][k] = input[index[i][j][k]][j][k] # if dim == 0
|
|||
|
|
out[i][j][k] = input[i][index[i][j][k]][k] # if dim == 1
|
|||
|
|
out[i][j][k] = input[i][j][index[i][j][k]] # if dim == 2
|
|||
|
|
|
|||
|
|
:attr:`input` and :attr:`index` must have the same number of dimensions.
|
|||
|
|
It is also required that ``index.size(d) <= input.size(d)`` for all
|
|||
|
|
dimensions ``d != dim``. :attr:`out` will have the same shape as :attr:`index`.
|
|||
|
|
Note that ``input`` and ``index`` do not broadcast against each other.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the source tensor
|
|||
|
|
dim (int): the axis along which to index
|
|||
|
|
index (LongTensor): the indices of elements to gather
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
sparse_grad (bool, optional): If ``True``, gradient w.r.t. :attr:`input` will be a sparse tensor.
|
|||
|
|
out (Tensor, optional): the destination tensor
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> t = torch.tensor([[1, 2], [3, 4]])
|
|||
|
|
>>> torch.gather(t, 1, torch.tensor([[0, 0], [1, 0]]))
|
|||
|
|
tensor([[ 1, 1],
|
|||
|
|
[ 4, 3]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def gcd(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
gcd(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the element-wise greatest common divisor (GCD) of :attr:`input` and :attr:`other`.
|
|||
|
|
|
|||
|
|
Both :attr:`input` and :attr:`other` must have integer types.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
This defines :math:`gcd(0, 0) = 0`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
other (Tensor): the second input tensor
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([5, 10, 15])
|
|||
|
|
>>> b = torch.tensor([3, 4, 5])
|
|||
|
|
>>> torch.gcd(a, b)
|
|||
|
|
tensor([1, 2, 5])
|
|||
|
|
>>> c = torch.tensor([3])
|
|||
|
|
>>> torch.gcd(a, c)
|
|||
|
|
tensor([1, 1, 3])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def gcd_(input: Tensor, other: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def ge(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
ge(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes :math:`\text{input} \geq \text{other}` element-wise.
|
|||
|
|
|
|||
|
|
|
|||
|
|
The second argument can be a number or a tensor whose shape is
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with the first argument.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to compare
|
|||
|
|
other (Tensor or float): the tensor or value to compare
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A boolean tensor that is True where :attr:`input` is greater than or equal to :attr:`other` and False elsewhere
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.ge(torch.tensor([[1, 2], [3, 4]]), torch.tensor([[1, 1], [4, 4]]))
|
|||
|
|
tensor([[True, True], [False, True]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def ge(input: Tensor, other: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
ge(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes :math:`\text{input} \geq \text{other}` element-wise.
|
|||
|
|
|
|||
|
|
|
|||
|
|
The second argument can be a number or a tensor whose shape is
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with the first argument.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to compare
|
|||
|
|
other (Tensor or float): the tensor or value to compare
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A boolean tensor that is True where :attr:`input` is greater than or equal to :attr:`other` and False elsewhere
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.ge(torch.tensor([[1, 2], [3, 4]]), torch.tensor([[1, 1], [4, 4]]))
|
|||
|
|
tensor([[True, True], [False, True]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def geqrf(input: Tensor, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.geqrf:
|
|||
|
|
r"""
|
|||
|
|
geqrf(input, *, out=None) -> (Tensor, Tensor)
|
|||
|
|
|
|||
|
|
This is a low-level function for calling LAPACK's geqrf directly. This function
|
|||
|
|
returns a namedtuple (a, tau) as defined in `LAPACK documentation for geqrf`_ .
|
|||
|
|
|
|||
|
|
Computes a QR decomposition of :attr:`input`.
|
|||
|
|
Both `Q` and `R` matrices are stored in the same output tensor `a`.
|
|||
|
|
The elements of `R` are stored on and above the diagonal.
|
|||
|
|
Elementary reflectors (or Householder vectors) implicitly defining matrix `Q`
|
|||
|
|
are stored below the diagonal.
|
|||
|
|
The results of this function can be used together with :func:`torch.linalg.householder_product`
|
|||
|
|
to obtain the `Q` matrix or
|
|||
|
|
with :func:`torch.ormqr`, which uses an implicit representation of the `Q` matrix,
|
|||
|
|
for an efficient matrix-matrix multiplication.
|
|||
|
|
|
|||
|
|
See `LAPACK documentation for geqrf`_ for further details.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
See also :func:`torch.linalg.qr`, which computes Q and R matrices, and :func:`torch.linalg.lstsq`
|
|||
|
|
with the ``driver="gels"`` option for a function that can solve matrix equations using a QR decomposition.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input matrix
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the output tuple of (Tensor, Tensor). Ignored if `None`. Default: `None`.
|
|||
|
|
|
|||
|
|
.. _LAPACK documentation for geqrf:
|
|||
|
|
http://www.netlib.org/lapack/explore-html/df/dc5/group__variants_g_ecomputational_ga3766ea903391b5cf9008132f7440ec7b.html
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def ger(input: Tensor, vec2: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
ger(input, vec2, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias of :func:`torch.outer`.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
This function is deprecated and will be removed in a future PyTorch release.
|
|||
|
|
Use :func:`torch.outer` instead.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def get_default_dtype() -> _dtype:
|
|||
|
|
r"""
|
|||
|
|
get_default_dtype() -> torch.dtype
|
|||
|
|
|
|||
|
|
Get the current default floating point :class:`torch.dtype`.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.get_default_dtype() # initial default for floating point is torch.float32
|
|||
|
|
torch.float32
|
|||
|
|
>>> torch.set_default_dtype(torch.float64)
|
|||
|
|
>>> torch.get_default_dtype() # default is now changed to torch.float64
|
|||
|
|
torch.float64
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def get_num_interop_threads() -> _int:
|
|||
|
|
r"""
|
|||
|
|
get_num_interop_threads() -> int
|
|||
|
|
|
|||
|
|
Returns the number of threads used for inter-op parallelism on CPU
|
|||
|
|
(e.g. in JIT interpreter)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def get_num_threads() -> _int:
|
|||
|
|
r"""
|
|||
|
|
get_num_threads() -> int
|
|||
|
|
|
|||
|
|
Returns the number of threads used for parallelizing CPU operations
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def gradient(input: Tensor, *, spacing: Optional[Union[Number, _complex]] = None, dim: Optional[_int] = None, edge_order: _int = 1) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
gradient(input, *, spacing=1, dim=None, edge_order=1) -> List of Tensors
|
|||
|
|
|
|||
|
|
Estimates the gradient of a function :math:`g : \mathbb{R}^n \rightarrow \mathbb{R}` in
|
|||
|
|
one or more dimensions using the `second-order accurate central differences method
|
|||
|
|
<https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_ and
|
|||
|
|
either first or second order estimates at the boundaries.
|
|||
|
|
|
|||
|
|
The gradient of :math:`g` is estimated using samples. By default, when :attr:`spacing` is not
|
|||
|
|
specified, the samples are entirely described by :attr:`input`, and the mapping of input coordinates
|
|||
|
|
to an output is the same as the tensor's mapping of indices to values. For example, for a three-dimensional
|
|||
|
|
:attr:`input` the function described is :math:`g : \mathbb{R}^3 \rightarrow \mathbb{R}`, and
|
|||
|
|
:math:`g(1, 2, 3)\ == input[1, 2, 3]`.
|
|||
|
|
|
|||
|
|
When :attr:`spacing` is specified, it modifies the relationship between :attr:`input` and input coordinates.
|
|||
|
|
This is detailed in the "Keyword Arguments" section below.
|
|||
|
|
|
|||
|
|
The gradient is estimated by estimating each partial derivative of :math:`g` independently. This estimation is
|
|||
|
|
accurate if :math:`g` is in :math:`C^3` (it has at least 3 continuous derivatives), and the estimation can be
|
|||
|
|
improved by providing closer samples. Mathematically, the value at each interior point of a partial derivative
|
|||
|
|
is estimated using `Taylor<EFBFBD>s theorem with remainder <https://en.wikipedia.org/wiki/Taylor%27s_theorem>`_.
|
|||
|
|
Letting :math:`x` be an interior point with :math:`x-h_l` and :math:`x+h_r` be points neighboring
|
|||
|
|
it to the left and right respectively, :math:`f(x+h_r)` and :math:`f(x-h_l)` can be estimated using:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\begin{aligned}
|
|||
|
|
f(x+h_r) = f(x) + h_r f'(x) + {h_r}^2 \frac{f''(x)}{2} + {h_r}^3 \frac{f'''(\xi_1)}{6}, \xi_1 \in (x, x+h_r) \\
|
|||
|
|
f(x-h_l) = f(x) - h_l f'(x) + {h_l}^2 \frac{f''(x)}{2} - {h_l}^3 \frac{f'''(\xi_2)}{6}, \xi_2 \in (x, x-h_l) \\
|
|||
|
|
\end{aligned}
|
|||
|
|
|
|||
|
|
Using the fact that :math:`f \in C^3` and solving the linear system, we derive:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
f'(x) \approx \frac{ {h_l}^2 f(x+h_r) - {h_r}^2 f(x-h_l)
|
|||
|
|
+ ({h_r}^2-{h_l}^2 ) f(x) }{ {h_r} {h_l}^2 + {h_r}^2 {h_l} }
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
We estimate the gradient of functions in complex domain
|
|||
|
|
:math:`g : \mathbb{C}^n \rightarrow \mathbb{C}` in the same way.
|
|||
|
|
|
|||
|
|
The value of each partial derivative at the boundary points is computed differently. See edge_order below.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (``Tensor``): the tensor that represents the values of the function
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
spacing (``scalar``, ``list of scalar``, ``list of Tensor``, optional): :attr:`spacing` can be used to modify
|
|||
|
|
how the :attr:`input` tensor's indices relate to sample coordinates. If :attr:`spacing` is a scalar then
|
|||
|
|
the indices are multiplied by the scalar to produce the coordinates. For example, if :attr:`spacing=2` the
|
|||
|
|
indices (1, 2, 3) become coordinates (2, 4, 6). If :attr:`spacing` is a list of scalars then the corresponding
|
|||
|
|
indices are multiplied. For example, if :attr:`spacing=(2, -1, 3)` the indices (1, 2, 3) become coordinates (2, -2, 9).
|
|||
|
|
Finally, if :attr:`spacing` is a list of one-dimensional tensors then each tensor specifies the coordinates for
|
|||
|
|
the corresponding dimension. For example, if the indices are (1, 2, 3) and the tensors are (t0, t1, t2), then
|
|||
|
|
the coordinates are (t0[1], t1[2], t2[3])
|
|||
|
|
|
|||
|
|
dim (``int``, ``list of int``, optional): the dimension or dimensions to approximate the gradient over. By default
|
|||
|
|
the partial gradient in every dimension is computed. Note that when :attr:`dim` is specified the elements of
|
|||
|
|
the :attr:`spacing` argument must correspond with the specified dims."
|
|||
|
|
|
|||
|
|
edge_order (``int``, optional): 1 or 2, for `first-order
|
|||
|
|
<https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_ or
|
|||
|
|
`second-order <https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_
|
|||
|
|
estimation of the boundary ("edge") values, respectively.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> # Estimates the gradient of f(x)=x^2 at points [-2, -1, 2, 4]
|
|||
|
|
>>> coordinates = (torch.tensor([-2., -1., 1., 4.]),)
|
|||
|
|
>>> values = torch.tensor([4., 1., 1., 16.], )
|
|||
|
|
>>> torch.gradient(values, spacing = coordinates)
|
|||
|
|
(tensor([-3., -2., 2., 5.]),)
|
|||
|
|
|
|||
|
|
>>> # Estimates the gradient of the R^2 -> R function whose samples are
|
|||
|
|
>>> # described by the tensor t. Implicit coordinates are [0, 1] for the outermost
|
|||
|
|
>>> # dimension and [0, 1, 2, 3] for the innermost dimension, and function estimates
|
|||
|
|
>>> # partial derivative for both dimensions.
|
|||
|
|
>>> t = torch.tensor([[1, 2, 4, 8], [10, 20, 40, 80]])
|
|||
|
|
>>> torch.gradient(t)
|
|||
|
|
(tensor([[ 9., 18., 36., 72.],
|
|||
|
|
[ 9., 18., 36., 72.]]),
|
|||
|
|
tensor([[ 1.0000, 1.5000, 3.0000, 4.0000],
|
|||
|
|
[10.0000, 15.0000, 30.0000, 40.0000]]))
|
|||
|
|
|
|||
|
|
>>> # A scalar value for spacing modifies the relationship between tensor indices
|
|||
|
|
>>> # and input coordinates by multiplying the indices to find the
|
|||
|
|
>>> # coordinates. For example, below the indices of the innermost
|
|||
|
|
>>> # 0, 1, 2, 3 translate to coordinates of [0, 2, 4, 6], and the indices of
|
|||
|
|
>>> # the outermost dimension 0, 1 translate to coordinates of [0, 2].
|
|||
|
|
>>> torch.gradient(t, spacing = 2.0) # dim = None (implicitly [0, 1])
|
|||
|
|
(tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
|
|||
|
|
[ 4.5000, 9.0000, 18.0000, 36.0000]]),
|
|||
|
|
tensor([[ 0.5000, 0.7500, 1.5000, 2.0000],
|
|||
|
|
[ 5.0000, 7.5000, 15.0000, 20.0000]]))
|
|||
|
|
>>> # doubling the spacing between samples halves the estimated partial gradients.
|
|||
|
|
|
|||
|
|
>>>
|
|||
|
|
>>> # Estimates only the partial derivative for dimension 1
|
|||
|
|
>>> torch.gradient(t, dim = 1) # spacing = None (implicitly 1.)
|
|||
|
|
(tensor([[ 1.0000, 1.5000, 3.0000, 4.0000],
|
|||
|
|
[10.0000, 15.0000, 30.0000, 40.0000]]),)
|
|||
|
|
|
|||
|
|
>>> # When spacing is a list of scalars, the relationship between the tensor
|
|||
|
|
>>> # indices and input coordinates changes based on dimension.
|
|||
|
|
>>> # For example, below, the indices of the innermost dimension 0, 1, 2, 3 translate
|
|||
|
|
>>> # to coordinates of [0, 3, 6, 9], and the indices of the outermost dimension
|
|||
|
|
>>> # 0, 1 translate to coordinates of [0, 2].
|
|||
|
|
>>> torch.gradient(t, spacing = [3., 2.])
|
|||
|
|
(tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
|
|||
|
|
[ 4.5000, 9.0000, 18.0000, 36.0000]]),
|
|||
|
|
tensor([[ 0.3333, 0.5000, 1.0000, 1.3333],
|
|||
|
|
[ 3.3333, 5.0000, 10.0000, 13.3333]]))
|
|||
|
|
|
|||
|
|
>>> # The following example is a replication of the previous one with explicit
|
|||
|
|
>>> # coordinates.
|
|||
|
|
>>> coords = (torch.tensor([0, 2]), torch.tensor([0, 3, 6, 9]))
|
|||
|
|
>>> torch.gradient(t, spacing = coords)
|
|||
|
|
(tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
|
|||
|
|
[ 4.5000, 9.0000, 18.0000, 36.0000]]),
|
|||
|
|
tensor([[ 0.3333, 0.5000, 1.0000, 1.3333],
|
|||
|
|
[ 3.3333, 5.0000, 10.0000, 13.3333]]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def gradient(input: Tensor, *, spacing: Sequence[Union[Number, _complex]], dim: Optional[_int] = None, edge_order: _int = 1) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
gradient(input, *, spacing=1, dim=None, edge_order=1) -> List of Tensors
|
|||
|
|
|
|||
|
|
Estimates the gradient of a function :math:`g : \mathbb{R}^n \rightarrow \mathbb{R}` in
|
|||
|
|
one or more dimensions using the `second-order accurate central differences method
|
|||
|
|
<https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_ and
|
|||
|
|
either first or second order estimates at the boundaries.
|
|||
|
|
|
|||
|
|
The gradient of :math:`g` is estimated using samples. By default, when :attr:`spacing` is not
|
|||
|
|
specified, the samples are entirely described by :attr:`input`, and the mapping of input coordinates
|
|||
|
|
to an output is the same as the tensor's mapping of indices to values. For example, for a three-dimensional
|
|||
|
|
:attr:`input` the function described is :math:`g : \mathbb{R}^3 \rightarrow \mathbb{R}`, and
|
|||
|
|
:math:`g(1, 2, 3)\ == input[1, 2, 3]`.
|
|||
|
|
|
|||
|
|
When :attr:`spacing` is specified, it modifies the relationship between :attr:`input` and input coordinates.
|
|||
|
|
This is detailed in the "Keyword Arguments" section below.
|
|||
|
|
|
|||
|
|
The gradient is estimated by estimating each partial derivative of :math:`g` independently. This estimation is
|
|||
|
|
accurate if :math:`g` is in :math:`C^3` (it has at least 3 continuous derivatives), and the estimation can be
|
|||
|
|
improved by providing closer samples. Mathematically, the value at each interior point of a partial derivative
|
|||
|
|
is estimated using `Taylor<EFBFBD>s theorem with remainder <https://en.wikipedia.org/wiki/Taylor%27s_theorem>`_.
|
|||
|
|
Letting :math:`x` be an interior point with :math:`x-h_l` and :math:`x+h_r` be points neighboring
|
|||
|
|
it to the left and right respectively, :math:`f(x+h_r)` and :math:`f(x-h_l)` can be estimated using:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\begin{aligned}
|
|||
|
|
f(x+h_r) = f(x) + h_r f'(x) + {h_r}^2 \frac{f''(x)}{2} + {h_r}^3 \frac{f'''(\xi_1)}{6}, \xi_1 \in (x, x+h_r) \\
|
|||
|
|
f(x-h_l) = f(x) - h_l f'(x) + {h_l}^2 \frac{f''(x)}{2} - {h_l}^3 \frac{f'''(\xi_2)}{6}, \xi_2 \in (x, x-h_l) \\
|
|||
|
|
\end{aligned}
|
|||
|
|
|
|||
|
|
Using the fact that :math:`f \in C^3` and solving the linear system, we derive:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
f'(x) \approx \frac{ {h_l}^2 f(x+h_r) - {h_r}^2 f(x-h_l)
|
|||
|
|
+ ({h_r}^2-{h_l}^2 ) f(x) }{ {h_r} {h_l}^2 + {h_r}^2 {h_l} }
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
We estimate the gradient of functions in complex domain
|
|||
|
|
:math:`g : \mathbb{C}^n \rightarrow \mathbb{C}` in the same way.
|
|||
|
|
|
|||
|
|
The value of each partial derivative at the boundary points is computed differently. See edge_order below.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (``Tensor``): the tensor that represents the values of the function
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
spacing (``scalar``, ``list of scalar``, ``list of Tensor``, optional): :attr:`spacing` can be used to modify
|
|||
|
|
how the :attr:`input` tensor's indices relate to sample coordinates. If :attr:`spacing` is a scalar then
|
|||
|
|
the indices are multiplied by the scalar to produce the coordinates. For example, if :attr:`spacing=2` the
|
|||
|
|
indices (1, 2, 3) become coordinates (2, 4, 6). If :attr:`spacing` is a list of scalars then the corresponding
|
|||
|
|
indices are multiplied. For example, if :attr:`spacing=(2, -1, 3)` the indices (1, 2, 3) become coordinates (2, -2, 9).
|
|||
|
|
Finally, if :attr:`spacing` is a list of one-dimensional tensors then each tensor specifies the coordinates for
|
|||
|
|
the corresponding dimension. For example, if the indices are (1, 2, 3) and the tensors are (t0, t1, t2), then
|
|||
|
|
the coordinates are (t0[1], t1[2], t2[3])
|
|||
|
|
|
|||
|
|
dim (``int``, ``list of int``, optional): the dimension or dimensions to approximate the gradient over. By default
|
|||
|
|
the partial gradient in every dimension is computed. Note that when :attr:`dim` is specified the elements of
|
|||
|
|
the :attr:`spacing` argument must correspond with the specified dims."
|
|||
|
|
|
|||
|
|
edge_order (``int``, optional): 1 or 2, for `first-order
|
|||
|
|
<https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_ or
|
|||
|
|
`second-order <https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_
|
|||
|
|
estimation of the boundary ("edge") values, respectively.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> # Estimates the gradient of f(x)=x^2 at points [-2, -1, 2, 4]
|
|||
|
|
>>> coordinates = (torch.tensor([-2., -1., 1., 4.]),)
|
|||
|
|
>>> values = torch.tensor([4., 1., 1., 16.], )
|
|||
|
|
>>> torch.gradient(values, spacing = coordinates)
|
|||
|
|
(tensor([-3., -2., 2., 5.]),)
|
|||
|
|
|
|||
|
|
>>> # Estimates the gradient of the R^2 -> R function whose samples are
|
|||
|
|
>>> # described by the tensor t. Implicit coordinates are [0, 1] for the outermost
|
|||
|
|
>>> # dimension and [0, 1, 2, 3] for the innermost dimension, and function estimates
|
|||
|
|
>>> # partial derivative for both dimensions.
|
|||
|
|
>>> t = torch.tensor([[1, 2, 4, 8], [10, 20, 40, 80]])
|
|||
|
|
>>> torch.gradient(t)
|
|||
|
|
(tensor([[ 9., 18., 36., 72.],
|
|||
|
|
[ 9., 18., 36., 72.]]),
|
|||
|
|
tensor([[ 1.0000, 1.5000, 3.0000, 4.0000],
|
|||
|
|
[10.0000, 15.0000, 30.0000, 40.0000]]))
|
|||
|
|
|
|||
|
|
>>> # A scalar value for spacing modifies the relationship between tensor indices
|
|||
|
|
>>> # and input coordinates by multiplying the indices to find the
|
|||
|
|
>>> # coordinates. For example, below the indices of the innermost
|
|||
|
|
>>> # 0, 1, 2, 3 translate to coordinates of [0, 2, 4, 6], and the indices of
|
|||
|
|
>>> # the outermost dimension 0, 1 translate to coordinates of [0, 2].
|
|||
|
|
>>> torch.gradient(t, spacing = 2.0) # dim = None (implicitly [0, 1])
|
|||
|
|
(tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
|
|||
|
|
[ 4.5000, 9.0000, 18.0000, 36.0000]]),
|
|||
|
|
tensor([[ 0.5000, 0.7500, 1.5000, 2.0000],
|
|||
|
|
[ 5.0000, 7.5000, 15.0000, 20.0000]]))
|
|||
|
|
>>> # doubling the spacing between samples halves the estimated partial gradients.
|
|||
|
|
|
|||
|
|
>>>
|
|||
|
|
>>> # Estimates only the partial derivative for dimension 1
|
|||
|
|
>>> torch.gradient(t, dim = 1) # spacing = None (implicitly 1.)
|
|||
|
|
(tensor([[ 1.0000, 1.5000, 3.0000, 4.0000],
|
|||
|
|
[10.0000, 15.0000, 30.0000, 40.0000]]),)
|
|||
|
|
|
|||
|
|
>>> # When spacing is a list of scalars, the relationship between the tensor
|
|||
|
|
>>> # indices and input coordinates changes based on dimension.
|
|||
|
|
>>> # For example, below, the indices of the innermost dimension 0, 1, 2, 3 translate
|
|||
|
|
>>> # to coordinates of [0, 3, 6, 9], and the indices of the outermost dimension
|
|||
|
|
>>> # 0, 1 translate to coordinates of [0, 2].
|
|||
|
|
>>> torch.gradient(t, spacing = [3., 2.])
|
|||
|
|
(tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
|
|||
|
|
[ 4.5000, 9.0000, 18.0000, 36.0000]]),
|
|||
|
|
tensor([[ 0.3333, 0.5000, 1.0000, 1.3333],
|
|||
|
|
[ 3.3333, 5.0000, 10.0000, 13.3333]]))
|
|||
|
|
|
|||
|
|
>>> # The following example is a replication of the previous one with explicit
|
|||
|
|
>>> # coordinates.
|
|||
|
|
>>> coords = (torch.tensor([0, 2]), torch.tensor([0, 3, 6, 9]))
|
|||
|
|
>>> torch.gradient(t, spacing = coords)
|
|||
|
|
(tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
|
|||
|
|
[ 4.5000, 9.0000, 18.0000, 36.0000]]),
|
|||
|
|
tensor([[ 0.3333, 0.5000, 1.0000, 1.3333],
|
|||
|
|
[ 3.3333, 5.0000, 10.0000, 13.3333]]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def gradient(input: Tensor, *, spacing: Sequence[Union[Number, _complex]], dim: _size, edge_order: _int = 1) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
gradient(input, *, spacing=1, dim=None, edge_order=1) -> List of Tensors
|
|||
|
|
|
|||
|
|
Estimates the gradient of a function :math:`g : \mathbb{R}^n \rightarrow \mathbb{R}` in
|
|||
|
|
one or more dimensions using the `second-order accurate central differences method
|
|||
|
|
<https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_ and
|
|||
|
|
either first or second order estimates at the boundaries.
|
|||
|
|
|
|||
|
|
The gradient of :math:`g` is estimated using samples. By default, when :attr:`spacing` is not
|
|||
|
|
specified, the samples are entirely described by :attr:`input`, and the mapping of input coordinates
|
|||
|
|
to an output is the same as the tensor's mapping of indices to values. For example, for a three-dimensional
|
|||
|
|
:attr:`input` the function described is :math:`g : \mathbb{R}^3 \rightarrow \mathbb{R}`, and
|
|||
|
|
:math:`g(1, 2, 3)\ == input[1, 2, 3]`.
|
|||
|
|
|
|||
|
|
When :attr:`spacing` is specified, it modifies the relationship between :attr:`input` and input coordinates.
|
|||
|
|
This is detailed in the "Keyword Arguments" section below.
|
|||
|
|
|
|||
|
|
The gradient is estimated by estimating each partial derivative of :math:`g` independently. This estimation is
|
|||
|
|
accurate if :math:`g` is in :math:`C^3` (it has at least 3 continuous derivatives), and the estimation can be
|
|||
|
|
improved by providing closer samples. Mathematically, the value at each interior point of a partial derivative
|
|||
|
|
is estimated using `Taylor<EFBFBD>s theorem with remainder <https://en.wikipedia.org/wiki/Taylor%27s_theorem>`_.
|
|||
|
|
Letting :math:`x` be an interior point with :math:`x-h_l` and :math:`x+h_r` be points neighboring
|
|||
|
|
it to the left and right respectively, :math:`f(x+h_r)` and :math:`f(x-h_l)` can be estimated using:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\begin{aligned}
|
|||
|
|
f(x+h_r) = f(x) + h_r f'(x) + {h_r}^2 \frac{f''(x)}{2} + {h_r}^3 \frac{f'''(\xi_1)}{6}, \xi_1 \in (x, x+h_r) \\
|
|||
|
|
f(x-h_l) = f(x) - h_l f'(x) + {h_l}^2 \frac{f''(x)}{2} - {h_l}^3 \frac{f'''(\xi_2)}{6}, \xi_2 \in (x, x-h_l) \\
|
|||
|
|
\end{aligned}
|
|||
|
|
|
|||
|
|
Using the fact that :math:`f \in C^3` and solving the linear system, we derive:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
f'(x) \approx \frac{ {h_l}^2 f(x+h_r) - {h_r}^2 f(x-h_l)
|
|||
|
|
+ ({h_r}^2-{h_l}^2 ) f(x) }{ {h_r} {h_l}^2 + {h_r}^2 {h_l} }
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
We estimate the gradient of functions in complex domain
|
|||
|
|
:math:`g : \mathbb{C}^n \rightarrow \mathbb{C}` in the same way.
|
|||
|
|
|
|||
|
|
The value of each partial derivative at the boundary points is computed differently. See edge_order below.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (``Tensor``): the tensor that represents the values of the function
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
spacing (``scalar``, ``list of scalar``, ``list of Tensor``, optional): :attr:`spacing` can be used to modify
|
|||
|
|
how the :attr:`input` tensor's indices relate to sample coordinates. If :attr:`spacing` is a scalar then
|
|||
|
|
the indices are multiplied by the scalar to produce the coordinates. For example, if :attr:`spacing=2` the
|
|||
|
|
indices (1, 2, 3) become coordinates (2, 4, 6). If :attr:`spacing` is a list of scalars then the corresponding
|
|||
|
|
indices are multiplied. For example, if :attr:`spacing=(2, -1, 3)` the indices (1, 2, 3) become coordinates (2, -2, 9).
|
|||
|
|
Finally, if :attr:`spacing` is a list of one-dimensional tensors then each tensor specifies the coordinates for
|
|||
|
|
the corresponding dimension. For example, if the indices are (1, 2, 3) and the tensors are (t0, t1, t2), then
|
|||
|
|
the coordinates are (t0[1], t1[2], t2[3])
|
|||
|
|
|
|||
|
|
dim (``int``, ``list of int``, optional): the dimension or dimensions to approximate the gradient over. By default
|
|||
|
|
the partial gradient in every dimension is computed. Note that when :attr:`dim` is specified the elements of
|
|||
|
|
the :attr:`spacing` argument must correspond with the specified dims."
|
|||
|
|
|
|||
|
|
edge_order (``int``, optional): 1 or 2, for `first-order
|
|||
|
|
<https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_ or
|
|||
|
|
`second-order <https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_
|
|||
|
|
estimation of the boundary ("edge") values, respectively.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> # Estimates the gradient of f(x)=x^2 at points [-2, -1, 2, 4]
|
|||
|
|
>>> coordinates = (torch.tensor([-2., -1., 1., 4.]),)
|
|||
|
|
>>> values = torch.tensor([4., 1., 1., 16.], )
|
|||
|
|
>>> torch.gradient(values, spacing = coordinates)
|
|||
|
|
(tensor([-3., -2., 2., 5.]),)
|
|||
|
|
|
|||
|
|
>>> # Estimates the gradient of the R^2 -> R function whose samples are
|
|||
|
|
>>> # described by the tensor t. Implicit coordinates are [0, 1] for the outermost
|
|||
|
|
>>> # dimension and [0, 1, 2, 3] for the innermost dimension, and function estimates
|
|||
|
|
>>> # partial derivative for both dimensions.
|
|||
|
|
>>> t = torch.tensor([[1, 2, 4, 8], [10, 20, 40, 80]])
|
|||
|
|
>>> torch.gradient(t)
|
|||
|
|
(tensor([[ 9., 18., 36., 72.],
|
|||
|
|
[ 9., 18., 36., 72.]]),
|
|||
|
|
tensor([[ 1.0000, 1.5000, 3.0000, 4.0000],
|
|||
|
|
[10.0000, 15.0000, 30.0000, 40.0000]]))
|
|||
|
|
|
|||
|
|
>>> # A scalar value for spacing modifies the relationship between tensor indices
|
|||
|
|
>>> # and input coordinates by multiplying the indices to find the
|
|||
|
|
>>> # coordinates. For example, below the indices of the innermost
|
|||
|
|
>>> # 0, 1, 2, 3 translate to coordinates of [0, 2, 4, 6], and the indices of
|
|||
|
|
>>> # the outermost dimension 0, 1 translate to coordinates of [0, 2].
|
|||
|
|
>>> torch.gradient(t, spacing = 2.0) # dim = None (implicitly [0, 1])
|
|||
|
|
(tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
|
|||
|
|
[ 4.5000, 9.0000, 18.0000, 36.0000]]),
|
|||
|
|
tensor([[ 0.5000, 0.7500, 1.5000, 2.0000],
|
|||
|
|
[ 5.0000, 7.5000, 15.0000, 20.0000]]))
|
|||
|
|
>>> # doubling the spacing between samples halves the estimated partial gradients.
|
|||
|
|
|
|||
|
|
>>>
|
|||
|
|
>>> # Estimates only the partial derivative for dimension 1
|
|||
|
|
>>> torch.gradient(t, dim = 1) # spacing = None (implicitly 1.)
|
|||
|
|
(tensor([[ 1.0000, 1.5000, 3.0000, 4.0000],
|
|||
|
|
[10.0000, 15.0000, 30.0000, 40.0000]]),)
|
|||
|
|
|
|||
|
|
>>> # When spacing is a list of scalars, the relationship between the tensor
|
|||
|
|
>>> # indices and input coordinates changes based on dimension.
|
|||
|
|
>>> # For example, below, the indices of the innermost dimension 0, 1, 2, 3 translate
|
|||
|
|
>>> # to coordinates of [0, 3, 6, 9], and the indices of the outermost dimension
|
|||
|
|
>>> # 0, 1 translate to coordinates of [0, 2].
|
|||
|
|
>>> torch.gradient(t, spacing = [3., 2.])
|
|||
|
|
(tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
|
|||
|
|
[ 4.5000, 9.0000, 18.0000, 36.0000]]),
|
|||
|
|
tensor([[ 0.3333, 0.5000, 1.0000, 1.3333],
|
|||
|
|
[ 3.3333, 5.0000, 10.0000, 13.3333]]))
|
|||
|
|
|
|||
|
|
>>> # The following example is a replication of the previous one with explicit
|
|||
|
|
>>> # coordinates.
|
|||
|
|
>>> coords = (torch.tensor([0, 2]), torch.tensor([0, 3, 6, 9]))
|
|||
|
|
>>> torch.gradient(t, spacing = coords)
|
|||
|
|
(tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
|
|||
|
|
[ 4.5000, 9.0000, 18.0000, 36.0000]]),
|
|||
|
|
tensor([[ 0.3333, 0.5000, 1.0000, 1.3333],
|
|||
|
|
[ 3.3333, 5.0000, 10.0000, 13.3333]]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def gradient(input: Tensor, *, spacing: Union[Tuple[Tensor, ...], List[Tensor]], dim: Optional[_int] = None, edge_order: _int = 1) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
gradient(input, *, spacing=1, dim=None, edge_order=1) -> List of Tensors
|
|||
|
|
|
|||
|
|
Estimates the gradient of a function :math:`g : \mathbb{R}^n \rightarrow \mathbb{R}` in
|
|||
|
|
one or more dimensions using the `second-order accurate central differences method
|
|||
|
|
<https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_ and
|
|||
|
|
either first or second order estimates at the boundaries.
|
|||
|
|
|
|||
|
|
The gradient of :math:`g` is estimated using samples. By default, when :attr:`spacing` is not
|
|||
|
|
specified, the samples are entirely described by :attr:`input`, and the mapping of input coordinates
|
|||
|
|
to an output is the same as the tensor's mapping of indices to values. For example, for a three-dimensional
|
|||
|
|
:attr:`input` the function described is :math:`g : \mathbb{R}^3 \rightarrow \mathbb{R}`, and
|
|||
|
|
:math:`g(1, 2, 3)\ == input[1, 2, 3]`.
|
|||
|
|
|
|||
|
|
When :attr:`spacing` is specified, it modifies the relationship between :attr:`input` and input coordinates.
|
|||
|
|
This is detailed in the "Keyword Arguments" section below.
|
|||
|
|
|
|||
|
|
The gradient is estimated by estimating each partial derivative of :math:`g` independently. This estimation is
|
|||
|
|
accurate if :math:`g` is in :math:`C^3` (it has at least 3 continuous derivatives), and the estimation can be
|
|||
|
|
improved by providing closer samples. Mathematically, the value at each interior point of a partial derivative
|
|||
|
|
is estimated using `Taylor<EFBFBD>s theorem with remainder <https://en.wikipedia.org/wiki/Taylor%27s_theorem>`_.
|
|||
|
|
Letting :math:`x` be an interior point with :math:`x-h_l` and :math:`x+h_r` be points neighboring
|
|||
|
|
it to the left and right respectively, :math:`f(x+h_r)` and :math:`f(x-h_l)` can be estimated using:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\begin{aligned}
|
|||
|
|
f(x+h_r) = f(x) + h_r f'(x) + {h_r}^2 \frac{f''(x)}{2} + {h_r}^3 \frac{f'''(\xi_1)}{6}, \xi_1 \in (x, x+h_r) \\
|
|||
|
|
f(x-h_l) = f(x) - h_l f'(x) + {h_l}^2 \frac{f''(x)}{2} - {h_l}^3 \frac{f'''(\xi_2)}{6}, \xi_2 \in (x, x-h_l) \\
|
|||
|
|
\end{aligned}
|
|||
|
|
|
|||
|
|
Using the fact that :math:`f \in C^3` and solving the linear system, we derive:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
f'(x) \approx \frac{ {h_l}^2 f(x+h_r) - {h_r}^2 f(x-h_l)
|
|||
|
|
+ ({h_r}^2-{h_l}^2 ) f(x) }{ {h_r} {h_l}^2 + {h_r}^2 {h_l} }
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
We estimate the gradient of functions in complex domain
|
|||
|
|
:math:`g : \mathbb{C}^n \rightarrow \mathbb{C}` in the same way.
|
|||
|
|
|
|||
|
|
The value of each partial derivative at the boundary points is computed differently. See edge_order below.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (``Tensor``): the tensor that represents the values of the function
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
spacing (``scalar``, ``list of scalar``, ``list of Tensor``, optional): :attr:`spacing` can be used to modify
|
|||
|
|
how the :attr:`input` tensor's indices relate to sample coordinates. If :attr:`spacing` is a scalar then
|
|||
|
|
the indices are multiplied by the scalar to produce the coordinates. For example, if :attr:`spacing=2` the
|
|||
|
|
indices (1, 2, 3) become coordinates (2, 4, 6). If :attr:`spacing` is a list of scalars then the corresponding
|
|||
|
|
indices are multiplied. For example, if :attr:`spacing=(2, -1, 3)` the indices (1, 2, 3) become coordinates (2, -2, 9).
|
|||
|
|
Finally, if :attr:`spacing` is a list of one-dimensional tensors then each tensor specifies the coordinates for
|
|||
|
|
the corresponding dimension. For example, if the indices are (1, 2, 3) and the tensors are (t0, t1, t2), then
|
|||
|
|
the coordinates are (t0[1], t1[2], t2[3])
|
|||
|
|
|
|||
|
|
dim (``int``, ``list of int``, optional): the dimension or dimensions to approximate the gradient over. By default
|
|||
|
|
the partial gradient in every dimension is computed. Note that when :attr:`dim` is specified the elements of
|
|||
|
|
the :attr:`spacing` argument must correspond with the specified dims."
|
|||
|
|
|
|||
|
|
edge_order (``int``, optional): 1 or 2, for `first-order
|
|||
|
|
<https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_ or
|
|||
|
|
`second-order <https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_
|
|||
|
|
estimation of the boundary ("edge") values, respectively.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> # Estimates the gradient of f(x)=x^2 at points [-2, -1, 2, 4]
|
|||
|
|
>>> coordinates = (torch.tensor([-2., -1., 1., 4.]),)
|
|||
|
|
>>> values = torch.tensor([4., 1., 1., 16.], )
|
|||
|
|
>>> torch.gradient(values, spacing = coordinates)
|
|||
|
|
(tensor([-3., -2., 2., 5.]),)
|
|||
|
|
|
|||
|
|
>>> # Estimates the gradient of the R^2 -> R function whose samples are
|
|||
|
|
>>> # described by the tensor t. Implicit coordinates are [0, 1] for the outermost
|
|||
|
|
>>> # dimension and [0, 1, 2, 3] for the innermost dimension, and function estimates
|
|||
|
|
>>> # partial derivative for both dimensions.
|
|||
|
|
>>> t = torch.tensor([[1, 2, 4, 8], [10, 20, 40, 80]])
|
|||
|
|
>>> torch.gradient(t)
|
|||
|
|
(tensor([[ 9., 18., 36., 72.],
|
|||
|
|
[ 9., 18., 36., 72.]]),
|
|||
|
|
tensor([[ 1.0000, 1.5000, 3.0000, 4.0000],
|
|||
|
|
[10.0000, 15.0000, 30.0000, 40.0000]]))
|
|||
|
|
|
|||
|
|
>>> # A scalar value for spacing modifies the relationship between tensor indices
|
|||
|
|
>>> # and input coordinates by multiplying the indices to find the
|
|||
|
|
>>> # coordinates. For example, below the indices of the innermost
|
|||
|
|
>>> # 0, 1, 2, 3 translate to coordinates of [0, 2, 4, 6], and the indices of
|
|||
|
|
>>> # the outermost dimension 0, 1 translate to coordinates of [0, 2].
|
|||
|
|
>>> torch.gradient(t, spacing = 2.0) # dim = None (implicitly [0, 1])
|
|||
|
|
(tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
|
|||
|
|
[ 4.5000, 9.0000, 18.0000, 36.0000]]),
|
|||
|
|
tensor([[ 0.5000, 0.7500, 1.5000, 2.0000],
|
|||
|
|
[ 5.0000, 7.5000, 15.0000, 20.0000]]))
|
|||
|
|
>>> # doubling the spacing between samples halves the estimated partial gradients.
|
|||
|
|
|
|||
|
|
>>>
|
|||
|
|
>>> # Estimates only the partial derivative for dimension 1
|
|||
|
|
>>> torch.gradient(t, dim = 1) # spacing = None (implicitly 1.)
|
|||
|
|
(tensor([[ 1.0000, 1.5000, 3.0000, 4.0000],
|
|||
|
|
[10.0000, 15.0000, 30.0000, 40.0000]]),)
|
|||
|
|
|
|||
|
|
>>> # When spacing is a list of scalars, the relationship between the tensor
|
|||
|
|
>>> # indices and input coordinates changes based on dimension.
|
|||
|
|
>>> # For example, below, the indices of the innermost dimension 0, 1, 2, 3 translate
|
|||
|
|
>>> # to coordinates of [0, 3, 6, 9], and the indices of the outermost dimension
|
|||
|
|
>>> # 0, 1 translate to coordinates of [0, 2].
|
|||
|
|
>>> torch.gradient(t, spacing = [3., 2.])
|
|||
|
|
(tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
|
|||
|
|
[ 4.5000, 9.0000, 18.0000, 36.0000]]),
|
|||
|
|
tensor([[ 0.3333, 0.5000, 1.0000, 1.3333],
|
|||
|
|
[ 3.3333, 5.0000, 10.0000, 13.3333]]))
|
|||
|
|
|
|||
|
|
>>> # The following example is a replication of the previous one with explicit
|
|||
|
|
>>> # coordinates.
|
|||
|
|
>>> coords = (torch.tensor([0, 2]), torch.tensor([0, 3, 6, 9]))
|
|||
|
|
>>> torch.gradient(t, spacing = coords)
|
|||
|
|
(tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
|
|||
|
|
[ 4.5000, 9.0000, 18.0000, 36.0000]]),
|
|||
|
|
tensor([[ 0.3333, 0.5000, 1.0000, 1.3333],
|
|||
|
|
[ 3.3333, 5.0000, 10.0000, 13.3333]]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def gradient(input: Tensor, *, spacing: Union[Number, _complex], dim: _size, edge_order: _int = 1) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
gradient(input, *, spacing=1, dim=None, edge_order=1) -> List of Tensors
|
|||
|
|
|
|||
|
|
Estimates the gradient of a function :math:`g : \mathbb{R}^n \rightarrow \mathbb{R}` in
|
|||
|
|
one or more dimensions using the `second-order accurate central differences method
|
|||
|
|
<https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_ and
|
|||
|
|
either first or second order estimates at the boundaries.
|
|||
|
|
|
|||
|
|
The gradient of :math:`g` is estimated using samples. By default, when :attr:`spacing` is not
|
|||
|
|
specified, the samples are entirely described by :attr:`input`, and the mapping of input coordinates
|
|||
|
|
to an output is the same as the tensor's mapping of indices to values. For example, for a three-dimensional
|
|||
|
|
:attr:`input` the function described is :math:`g : \mathbb{R}^3 \rightarrow \mathbb{R}`, and
|
|||
|
|
:math:`g(1, 2, 3)\ == input[1, 2, 3]`.
|
|||
|
|
|
|||
|
|
When :attr:`spacing` is specified, it modifies the relationship between :attr:`input` and input coordinates.
|
|||
|
|
This is detailed in the "Keyword Arguments" section below.
|
|||
|
|
|
|||
|
|
The gradient is estimated by estimating each partial derivative of :math:`g` independently. This estimation is
|
|||
|
|
accurate if :math:`g` is in :math:`C^3` (it has at least 3 continuous derivatives), and the estimation can be
|
|||
|
|
improved by providing closer samples. Mathematically, the value at each interior point of a partial derivative
|
|||
|
|
is estimated using `Taylor<EFBFBD>s theorem with remainder <https://en.wikipedia.org/wiki/Taylor%27s_theorem>`_.
|
|||
|
|
Letting :math:`x` be an interior point with :math:`x-h_l` and :math:`x+h_r` be points neighboring
|
|||
|
|
it to the left and right respectively, :math:`f(x+h_r)` and :math:`f(x-h_l)` can be estimated using:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\begin{aligned}
|
|||
|
|
f(x+h_r) = f(x) + h_r f'(x) + {h_r}^2 \frac{f''(x)}{2} + {h_r}^3 \frac{f'''(\xi_1)}{6}, \xi_1 \in (x, x+h_r) \\
|
|||
|
|
f(x-h_l) = f(x) - h_l f'(x) + {h_l}^2 \frac{f''(x)}{2} - {h_l}^3 \frac{f'''(\xi_2)}{6}, \xi_2 \in (x, x-h_l) \\
|
|||
|
|
\end{aligned}
|
|||
|
|
|
|||
|
|
Using the fact that :math:`f \in C^3` and solving the linear system, we derive:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
f'(x) \approx \frac{ {h_l}^2 f(x+h_r) - {h_r}^2 f(x-h_l)
|
|||
|
|
+ ({h_r}^2-{h_l}^2 ) f(x) }{ {h_r} {h_l}^2 + {h_r}^2 {h_l} }
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
We estimate the gradient of functions in complex domain
|
|||
|
|
:math:`g : \mathbb{C}^n \rightarrow \mathbb{C}` in the same way.
|
|||
|
|
|
|||
|
|
The value of each partial derivative at the boundary points is computed differently. See edge_order below.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (``Tensor``): the tensor that represents the values of the function
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
spacing (``scalar``, ``list of scalar``, ``list of Tensor``, optional): :attr:`spacing` can be used to modify
|
|||
|
|
how the :attr:`input` tensor's indices relate to sample coordinates. If :attr:`spacing` is a scalar then
|
|||
|
|
the indices are multiplied by the scalar to produce the coordinates. For example, if :attr:`spacing=2` the
|
|||
|
|
indices (1, 2, 3) become coordinates (2, 4, 6). If :attr:`spacing` is a list of scalars then the corresponding
|
|||
|
|
indices are multiplied. For example, if :attr:`spacing=(2, -1, 3)` the indices (1, 2, 3) become coordinates (2, -2, 9).
|
|||
|
|
Finally, if :attr:`spacing` is a list of one-dimensional tensors then each tensor specifies the coordinates for
|
|||
|
|
the corresponding dimension. For example, if the indices are (1, 2, 3) and the tensors are (t0, t1, t2), then
|
|||
|
|
the coordinates are (t0[1], t1[2], t2[3])
|
|||
|
|
|
|||
|
|
dim (``int``, ``list of int``, optional): the dimension or dimensions to approximate the gradient over. By default
|
|||
|
|
the partial gradient in every dimension is computed. Note that when :attr:`dim` is specified the elements of
|
|||
|
|
the :attr:`spacing` argument must correspond with the specified dims."
|
|||
|
|
|
|||
|
|
edge_order (``int``, optional): 1 or 2, for `first-order
|
|||
|
|
<https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_ or
|
|||
|
|
`second-order <https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_
|
|||
|
|
estimation of the boundary ("edge") values, respectively.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> # Estimates the gradient of f(x)=x^2 at points [-2, -1, 2, 4]
|
|||
|
|
>>> coordinates = (torch.tensor([-2., -1., 1., 4.]),)
|
|||
|
|
>>> values = torch.tensor([4., 1., 1., 16.], )
|
|||
|
|
>>> torch.gradient(values, spacing = coordinates)
|
|||
|
|
(tensor([-3., -2., 2., 5.]),)
|
|||
|
|
|
|||
|
|
>>> # Estimates the gradient of the R^2 -> R function whose samples are
|
|||
|
|
>>> # described by the tensor t. Implicit coordinates are [0, 1] for the outermost
|
|||
|
|
>>> # dimension and [0, 1, 2, 3] for the innermost dimension, and function estimates
|
|||
|
|
>>> # partial derivative for both dimensions.
|
|||
|
|
>>> t = torch.tensor([[1, 2, 4, 8], [10, 20, 40, 80]])
|
|||
|
|
>>> torch.gradient(t)
|
|||
|
|
(tensor([[ 9., 18., 36., 72.],
|
|||
|
|
[ 9., 18., 36., 72.]]),
|
|||
|
|
tensor([[ 1.0000, 1.5000, 3.0000, 4.0000],
|
|||
|
|
[10.0000, 15.0000, 30.0000, 40.0000]]))
|
|||
|
|
|
|||
|
|
>>> # A scalar value for spacing modifies the relationship between tensor indices
|
|||
|
|
>>> # and input coordinates by multiplying the indices to find the
|
|||
|
|
>>> # coordinates. For example, below the indices of the innermost
|
|||
|
|
>>> # 0, 1, 2, 3 translate to coordinates of [0, 2, 4, 6], and the indices of
|
|||
|
|
>>> # the outermost dimension 0, 1 translate to coordinates of [0, 2].
|
|||
|
|
>>> torch.gradient(t, spacing = 2.0) # dim = None (implicitly [0, 1])
|
|||
|
|
(tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
|
|||
|
|
[ 4.5000, 9.0000, 18.0000, 36.0000]]),
|
|||
|
|
tensor([[ 0.5000, 0.7500, 1.5000, 2.0000],
|
|||
|
|
[ 5.0000, 7.5000, 15.0000, 20.0000]]))
|
|||
|
|
>>> # doubling the spacing between samples halves the estimated partial gradients.
|
|||
|
|
|
|||
|
|
>>>
|
|||
|
|
>>> # Estimates only the partial derivative for dimension 1
|
|||
|
|
>>> torch.gradient(t, dim = 1) # spacing = None (implicitly 1.)
|
|||
|
|
(tensor([[ 1.0000, 1.5000, 3.0000, 4.0000],
|
|||
|
|
[10.0000, 15.0000, 30.0000, 40.0000]]),)
|
|||
|
|
|
|||
|
|
>>> # When spacing is a list of scalars, the relationship between the tensor
|
|||
|
|
>>> # indices and input coordinates changes based on dimension.
|
|||
|
|
>>> # For example, below, the indices of the innermost dimension 0, 1, 2, 3 translate
|
|||
|
|
>>> # to coordinates of [0, 3, 6, 9], and the indices of the outermost dimension
|
|||
|
|
>>> # 0, 1 translate to coordinates of [0, 2].
|
|||
|
|
>>> torch.gradient(t, spacing = [3., 2.])
|
|||
|
|
(tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
|
|||
|
|
[ 4.5000, 9.0000, 18.0000, 36.0000]]),
|
|||
|
|
tensor([[ 0.3333, 0.5000, 1.0000, 1.3333],
|
|||
|
|
[ 3.3333, 5.0000, 10.0000, 13.3333]]))
|
|||
|
|
|
|||
|
|
>>> # The following example is a replication of the previous one with explicit
|
|||
|
|
>>> # coordinates.
|
|||
|
|
>>> coords = (torch.tensor([0, 2]), torch.tensor([0, 3, 6, 9]))
|
|||
|
|
>>> torch.gradient(t, spacing = coords)
|
|||
|
|
(tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
|
|||
|
|
[ 4.5000, 9.0000, 18.0000, 36.0000]]),
|
|||
|
|
tensor([[ 0.3333, 0.5000, 1.0000, 1.3333],
|
|||
|
|
[ 3.3333, 5.0000, 10.0000, 13.3333]]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def gradient(input: Tensor, *, spacing: Union[Tuple[Tensor, ...], List[Tensor]], dim: _size, edge_order: _int = 1) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
gradient(input, *, spacing=1, dim=None, edge_order=1) -> List of Tensors
|
|||
|
|
|
|||
|
|
Estimates the gradient of a function :math:`g : \mathbb{R}^n \rightarrow \mathbb{R}` in
|
|||
|
|
one or more dimensions using the `second-order accurate central differences method
|
|||
|
|
<https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_ and
|
|||
|
|
either first or second order estimates at the boundaries.
|
|||
|
|
|
|||
|
|
The gradient of :math:`g` is estimated using samples. By default, when :attr:`spacing` is not
|
|||
|
|
specified, the samples are entirely described by :attr:`input`, and the mapping of input coordinates
|
|||
|
|
to an output is the same as the tensor's mapping of indices to values. For example, for a three-dimensional
|
|||
|
|
:attr:`input` the function described is :math:`g : \mathbb{R}^3 \rightarrow \mathbb{R}`, and
|
|||
|
|
:math:`g(1, 2, 3)\ == input[1, 2, 3]`.
|
|||
|
|
|
|||
|
|
When :attr:`spacing` is specified, it modifies the relationship between :attr:`input` and input coordinates.
|
|||
|
|
This is detailed in the "Keyword Arguments" section below.
|
|||
|
|
|
|||
|
|
The gradient is estimated by estimating each partial derivative of :math:`g` independently. This estimation is
|
|||
|
|
accurate if :math:`g` is in :math:`C^3` (it has at least 3 continuous derivatives), and the estimation can be
|
|||
|
|
improved by providing closer samples. Mathematically, the value at each interior point of a partial derivative
|
|||
|
|
is estimated using `Taylor<EFBFBD>s theorem with remainder <https://en.wikipedia.org/wiki/Taylor%27s_theorem>`_.
|
|||
|
|
Letting :math:`x` be an interior point with :math:`x-h_l` and :math:`x+h_r` be points neighboring
|
|||
|
|
it to the left and right respectively, :math:`f(x+h_r)` and :math:`f(x-h_l)` can be estimated using:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\begin{aligned}
|
|||
|
|
f(x+h_r) = f(x) + h_r f'(x) + {h_r}^2 \frac{f''(x)}{2} + {h_r}^3 \frac{f'''(\xi_1)}{6}, \xi_1 \in (x, x+h_r) \\
|
|||
|
|
f(x-h_l) = f(x) - h_l f'(x) + {h_l}^2 \frac{f''(x)}{2} - {h_l}^3 \frac{f'''(\xi_2)}{6}, \xi_2 \in (x, x-h_l) \\
|
|||
|
|
\end{aligned}
|
|||
|
|
|
|||
|
|
Using the fact that :math:`f \in C^3` and solving the linear system, we derive:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
f'(x) \approx \frac{ {h_l}^2 f(x+h_r) - {h_r}^2 f(x-h_l)
|
|||
|
|
+ ({h_r}^2-{h_l}^2 ) f(x) }{ {h_r} {h_l}^2 + {h_r}^2 {h_l} }
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
We estimate the gradient of functions in complex domain
|
|||
|
|
:math:`g : \mathbb{C}^n \rightarrow \mathbb{C}` in the same way.
|
|||
|
|
|
|||
|
|
The value of each partial derivative at the boundary points is computed differently. See edge_order below.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (``Tensor``): the tensor that represents the values of the function
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
spacing (``scalar``, ``list of scalar``, ``list of Tensor``, optional): :attr:`spacing` can be used to modify
|
|||
|
|
how the :attr:`input` tensor's indices relate to sample coordinates. If :attr:`spacing` is a scalar then
|
|||
|
|
the indices are multiplied by the scalar to produce the coordinates. For example, if :attr:`spacing=2` the
|
|||
|
|
indices (1, 2, 3) become coordinates (2, 4, 6). If :attr:`spacing` is a list of scalars then the corresponding
|
|||
|
|
indices are multiplied. For example, if :attr:`spacing=(2, -1, 3)` the indices (1, 2, 3) become coordinates (2, -2, 9).
|
|||
|
|
Finally, if :attr:`spacing` is a list of one-dimensional tensors then each tensor specifies the coordinates for
|
|||
|
|
the corresponding dimension. For example, if the indices are (1, 2, 3) and the tensors are (t0, t1, t2), then
|
|||
|
|
the coordinates are (t0[1], t1[2], t2[3])
|
|||
|
|
|
|||
|
|
dim (``int``, ``list of int``, optional): the dimension or dimensions to approximate the gradient over. By default
|
|||
|
|
the partial gradient in every dimension is computed. Note that when :attr:`dim` is specified the elements of
|
|||
|
|
the :attr:`spacing` argument must correspond with the specified dims."
|
|||
|
|
|
|||
|
|
edge_order (``int``, optional): 1 or 2, for `first-order
|
|||
|
|
<https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_ or
|
|||
|
|
`second-order <https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_
|
|||
|
|
estimation of the boundary ("edge") values, respectively.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> # Estimates the gradient of f(x)=x^2 at points [-2, -1, 2, 4]
|
|||
|
|
>>> coordinates = (torch.tensor([-2., -1., 1., 4.]),)
|
|||
|
|
>>> values = torch.tensor([4., 1., 1., 16.], )
|
|||
|
|
>>> torch.gradient(values, spacing = coordinates)
|
|||
|
|
(tensor([-3., -2., 2., 5.]),)
|
|||
|
|
|
|||
|
|
>>> # Estimates the gradient of the R^2 -> R function whose samples are
|
|||
|
|
>>> # described by the tensor t. Implicit coordinates are [0, 1] for the outermost
|
|||
|
|
>>> # dimension and [0, 1, 2, 3] for the innermost dimension, and function estimates
|
|||
|
|
>>> # partial derivative for both dimensions.
|
|||
|
|
>>> t = torch.tensor([[1, 2, 4, 8], [10, 20, 40, 80]])
|
|||
|
|
>>> torch.gradient(t)
|
|||
|
|
(tensor([[ 9., 18., 36., 72.],
|
|||
|
|
[ 9., 18., 36., 72.]]),
|
|||
|
|
tensor([[ 1.0000, 1.5000, 3.0000, 4.0000],
|
|||
|
|
[10.0000, 15.0000, 30.0000, 40.0000]]))
|
|||
|
|
|
|||
|
|
>>> # A scalar value for spacing modifies the relationship between tensor indices
|
|||
|
|
>>> # and input coordinates by multiplying the indices to find the
|
|||
|
|
>>> # coordinates. For example, below the indices of the innermost
|
|||
|
|
>>> # 0, 1, 2, 3 translate to coordinates of [0, 2, 4, 6], and the indices of
|
|||
|
|
>>> # the outermost dimension 0, 1 translate to coordinates of [0, 2].
|
|||
|
|
>>> torch.gradient(t, spacing = 2.0) # dim = None (implicitly [0, 1])
|
|||
|
|
(tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
|
|||
|
|
[ 4.5000, 9.0000, 18.0000, 36.0000]]),
|
|||
|
|
tensor([[ 0.5000, 0.7500, 1.5000, 2.0000],
|
|||
|
|
[ 5.0000, 7.5000, 15.0000, 20.0000]]))
|
|||
|
|
>>> # doubling the spacing between samples halves the estimated partial gradients.
|
|||
|
|
|
|||
|
|
>>>
|
|||
|
|
>>> # Estimates only the partial derivative for dimension 1
|
|||
|
|
>>> torch.gradient(t, dim = 1) # spacing = None (implicitly 1.)
|
|||
|
|
(tensor([[ 1.0000, 1.5000, 3.0000, 4.0000],
|
|||
|
|
[10.0000, 15.0000, 30.0000, 40.0000]]),)
|
|||
|
|
|
|||
|
|
>>> # When spacing is a list of scalars, the relationship between the tensor
|
|||
|
|
>>> # indices and input coordinates changes based on dimension.
|
|||
|
|
>>> # For example, below, the indices of the innermost dimension 0, 1, 2, 3 translate
|
|||
|
|
>>> # to coordinates of [0, 3, 6, 9], and the indices of the outermost dimension
|
|||
|
|
>>> # 0, 1 translate to coordinates of [0, 2].
|
|||
|
|
>>> torch.gradient(t, spacing = [3., 2.])
|
|||
|
|
(tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
|
|||
|
|
[ 4.5000, 9.0000, 18.0000, 36.0000]]),
|
|||
|
|
tensor([[ 0.3333, 0.5000, 1.0000, 1.3333],
|
|||
|
|
[ 3.3333, 5.0000, 10.0000, 13.3333]]))
|
|||
|
|
|
|||
|
|
>>> # The following example is a replication of the previous one with explicit
|
|||
|
|
>>> # coordinates.
|
|||
|
|
>>> coords = (torch.tensor([0, 2]), torch.tensor([0, 3, 6, 9]))
|
|||
|
|
>>> torch.gradient(t, spacing = coords)
|
|||
|
|
(tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
|
|||
|
|
[ 4.5000, 9.0000, 18.0000, 36.0000]]),
|
|||
|
|
tensor([[ 0.3333, 0.5000, 1.0000, 1.3333],
|
|||
|
|
[ 3.3333, 5.0000, 10.0000, 13.3333]]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def gradient(input: Tensor, *, dim: _size, edge_order: _int = 1) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
gradient(input, *, spacing=1, dim=None, edge_order=1) -> List of Tensors
|
|||
|
|
|
|||
|
|
Estimates the gradient of a function :math:`g : \mathbb{R}^n \rightarrow \mathbb{R}` in
|
|||
|
|
one or more dimensions using the `second-order accurate central differences method
|
|||
|
|
<https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_ and
|
|||
|
|
either first or second order estimates at the boundaries.
|
|||
|
|
|
|||
|
|
The gradient of :math:`g` is estimated using samples. By default, when :attr:`spacing` is not
|
|||
|
|
specified, the samples are entirely described by :attr:`input`, and the mapping of input coordinates
|
|||
|
|
to an output is the same as the tensor's mapping of indices to values. For example, for a three-dimensional
|
|||
|
|
:attr:`input` the function described is :math:`g : \mathbb{R}^3 \rightarrow \mathbb{R}`, and
|
|||
|
|
:math:`g(1, 2, 3)\ == input[1, 2, 3]`.
|
|||
|
|
|
|||
|
|
When :attr:`spacing` is specified, it modifies the relationship between :attr:`input` and input coordinates.
|
|||
|
|
This is detailed in the "Keyword Arguments" section below.
|
|||
|
|
|
|||
|
|
The gradient is estimated by estimating each partial derivative of :math:`g` independently. This estimation is
|
|||
|
|
accurate if :math:`g` is in :math:`C^3` (it has at least 3 continuous derivatives), and the estimation can be
|
|||
|
|
improved by providing closer samples. Mathematically, the value at each interior point of a partial derivative
|
|||
|
|
is estimated using `Taylor<EFBFBD>s theorem with remainder <https://en.wikipedia.org/wiki/Taylor%27s_theorem>`_.
|
|||
|
|
Letting :math:`x` be an interior point with :math:`x-h_l` and :math:`x+h_r` be points neighboring
|
|||
|
|
it to the left and right respectively, :math:`f(x+h_r)` and :math:`f(x-h_l)` can be estimated using:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\begin{aligned}
|
|||
|
|
f(x+h_r) = f(x) + h_r f'(x) + {h_r}^2 \frac{f''(x)}{2} + {h_r}^3 \frac{f'''(\xi_1)}{6}, \xi_1 \in (x, x+h_r) \\
|
|||
|
|
f(x-h_l) = f(x) - h_l f'(x) + {h_l}^2 \frac{f''(x)}{2} - {h_l}^3 \frac{f'''(\xi_2)}{6}, \xi_2 \in (x, x-h_l) \\
|
|||
|
|
\end{aligned}
|
|||
|
|
|
|||
|
|
Using the fact that :math:`f \in C^3` and solving the linear system, we derive:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
f'(x) \approx \frac{ {h_l}^2 f(x+h_r) - {h_r}^2 f(x-h_l)
|
|||
|
|
+ ({h_r}^2-{h_l}^2 ) f(x) }{ {h_r} {h_l}^2 + {h_r}^2 {h_l} }
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
We estimate the gradient of functions in complex domain
|
|||
|
|
:math:`g : \mathbb{C}^n \rightarrow \mathbb{C}` in the same way.
|
|||
|
|
|
|||
|
|
The value of each partial derivative at the boundary points is computed differently. See edge_order below.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (``Tensor``): the tensor that represents the values of the function
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
spacing (``scalar``, ``list of scalar``, ``list of Tensor``, optional): :attr:`spacing` can be used to modify
|
|||
|
|
how the :attr:`input` tensor's indices relate to sample coordinates. If :attr:`spacing` is a scalar then
|
|||
|
|
the indices are multiplied by the scalar to produce the coordinates. For example, if :attr:`spacing=2` the
|
|||
|
|
indices (1, 2, 3) become coordinates (2, 4, 6). If :attr:`spacing` is a list of scalars then the corresponding
|
|||
|
|
indices are multiplied. For example, if :attr:`spacing=(2, -1, 3)` the indices (1, 2, 3) become coordinates (2, -2, 9).
|
|||
|
|
Finally, if :attr:`spacing` is a list of one-dimensional tensors then each tensor specifies the coordinates for
|
|||
|
|
the corresponding dimension. For example, if the indices are (1, 2, 3) and the tensors are (t0, t1, t2), then
|
|||
|
|
the coordinates are (t0[1], t1[2], t2[3])
|
|||
|
|
|
|||
|
|
dim (``int``, ``list of int``, optional): the dimension or dimensions to approximate the gradient over. By default
|
|||
|
|
the partial gradient in every dimension is computed. Note that when :attr:`dim` is specified the elements of
|
|||
|
|
the :attr:`spacing` argument must correspond with the specified dims."
|
|||
|
|
|
|||
|
|
edge_order (``int``, optional): 1 or 2, for `first-order
|
|||
|
|
<https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_ or
|
|||
|
|
`second-order <https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_
|
|||
|
|
estimation of the boundary ("edge") values, respectively.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> # Estimates the gradient of f(x)=x^2 at points [-2, -1, 2, 4]
|
|||
|
|
>>> coordinates = (torch.tensor([-2., -1., 1., 4.]),)
|
|||
|
|
>>> values = torch.tensor([4., 1., 1., 16.], )
|
|||
|
|
>>> torch.gradient(values, spacing = coordinates)
|
|||
|
|
(tensor([-3., -2., 2., 5.]),)
|
|||
|
|
|
|||
|
|
>>> # Estimates the gradient of the R^2 -> R function whose samples are
|
|||
|
|
>>> # described by the tensor t. Implicit coordinates are [0, 1] for the outermost
|
|||
|
|
>>> # dimension and [0, 1, 2, 3] for the innermost dimension, and function estimates
|
|||
|
|
>>> # partial derivative for both dimensions.
|
|||
|
|
>>> t = torch.tensor([[1, 2, 4, 8], [10, 20, 40, 80]])
|
|||
|
|
>>> torch.gradient(t)
|
|||
|
|
(tensor([[ 9., 18., 36., 72.],
|
|||
|
|
[ 9., 18., 36., 72.]]),
|
|||
|
|
tensor([[ 1.0000, 1.5000, 3.0000, 4.0000],
|
|||
|
|
[10.0000, 15.0000, 30.0000, 40.0000]]))
|
|||
|
|
|
|||
|
|
>>> # A scalar value for spacing modifies the relationship between tensor indices
|
|||
|
|
>>> # and input coordinates by multiplying the indices to find the
|
|||
|
|
>>> # coordinates. For example, below the indices of the innermost
|
|||
|
|
>>> # 0, 1, 2, 3 translate to coordinates of [0, 2, 4, 6], and the indices of
|
|||
|
|
>>> # the outermost dimension 0, 1 translate to coordinates of [0, 2].
|
|||
|
|
>>> torch.gradient(t, spacing = 2.0) # dim = None (implicitly [0, 1])
|
|||
|
|
(tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
|
|||
|
|
[ 4.5000, 9.0000, 18.0000, 36.0000]]),
|
|||
|
|
tensor([[ 0.5000, 0.7500, 1.5000, 2.0000],
|
|||
|
|
[ 5.0000, 7.5000, 15.0000, 20.0000]]))
|
|||
|
|
>>> # doubling the spacing between samples halves the estimated partial gradients.
|
|||
|
|
|
|||
|
|
>>>
|
|||
|
|
>>> # Estimates only the partial derivative for dimension 1
|
|||
|
|
>>> torch.gradient(t, dim = 1) # spacing = None (implicitly 1.)
|
|||
|
|
(tensor([[ 1.0000, 1.5000, 3.0000, 4.0000],
|
|||
|
|
[10.0000, 15.0000, 30.0000, 40.0000]]),)
|
|||
|
|
|
|||
|
|
>>> # When spacing is a list of scalars, the relationship between the tensor
|
|||
|
|
>>> # indices and input coordinates changes based on dimension.
|
|||
|
|
>>> # For example, below, the indices of the innermost dimension 0, 1, 2, 3 translate
|
|||
|
|
>>> # to coordinates of [0, 3, 6, 9], and the indices of the outermost dimension
|
|||
|
|
>>> # 0, 1 translate to coordinates of [0, 2].
|
|||
|
|
>>> torch.gradient(t, spacing = [3., 2.])
|
|||
|
|
(tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
|
|||
|
|
[ 4.5000, 9.0000, 18.0000, 36.0000]]),
|
|||
|
|
tensor([[ 0.3333, 0.5000, 1.0000, 1.3333],
|
|||
|
|
[ 3.3333, 5.0000, 10.0000, 13.3333]]))
|
|||
|
|
|
|||
|
|
>>> # The following example is a replication of the previous one with explicit
|
|||
|
|
>>> # coordinates.
|
|||
|
|
>>> coords = (torch.tensor([0, 2]), torch.tensor([0, 3, 6, 9]))
|
|||
|
|
>>> torch.gradient(t, spacing = coords)
|
|||
|
|
(tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
|
|||
|
|
[ 4.5000, 9.0000, 18.0000, 36.0000]]),
|
|||
|
|
tensor([[ 0.3333, 0.5000, 1.0000, 1.3333],
|
|||
|
|
[ 3.3333, 5.0000, 10.0000, 13.3333]]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def greater(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
greater(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.gt`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def greater(input: Tensor, other: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
greater(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.gt`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def greater_equal(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
greater_equal(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.ge`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def greater_equal(input: Tensor, other: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
greater_equal(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.ge`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def grid_sampler(input: Tensor, grid: Tensor, interpolation_mode: _int, padding_mode: _int, align_corners: _bool) -> Tensor: ...
|
|||
|
|
def grid_sampler_2d(input: Tensor, grid: Tensor, interpolation_mode: _int, padding_mode: _int, align_corners: _bool) -> Tensor: ...
|
|||
|
|
def grid_sampler_3d(input: Tensor, grid: Tensor, interpolation_mode: _int, padding_mode: _int, align_corners: _bool) -> Tensor: ...
|
|||
|
|
def group_norm(input: Tensor, num_groups: _int, weight: Optional[Tensor] = None, bias: Optional[Tensor] = None, eps: _float = 1e-05, cudnn_enabled: _bool = True) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def gru(data: Tensor, batch_sizes: Tensor, hx: Tensor, params: Union[Tuple[Tensor, ...], List[Tensor]], has_biases: _bool, num_layers: _int, dropout: _float, train: _bool, bidirectional: _bool) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
@overload
|
|||
|
|
def gru(input: Tensor, hx: Tensor, params: Union[Tuple[Tensor, ...], List[Tensor]], has_biases: _bool, num_layers: _int, dropout: _float, train: _bool, bidirectional: _bool, batch_first: _bool) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def gru_cell(input: Tensor, hx: Tensor, w_ih: Tensor, w_hh: Tensor, b_ih: Optional[Tensor] = None, b_hh: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def gt(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
gt(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes :math:`\text{input} > \text{other}` element-wise.
|
|||
|
|
|
|||
|
|
|
|||
|
|
The second argument can be a number or a tensor whose shape is
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with the first argument.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to compare
|
|||
|
|
other (Tensor or float): the tensor or value to compare
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A boolean tensor that is True where :attr:`input` is greater than :attr:`other` and False elsewhere
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.gt(torch.tensor([[1, 2], [3, 4]]), torch.tensor([[1, 1], [4, 4]]))
|
|||
|
|
tensor([[False, True], [False, False]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def gt(input: Tensor, other: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
gt(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes :math:`\text{input} > \text{other}` element-wise.
|
|||
|
|
|
|||
|
|
|
|||
|
|
The second argument can be a number or a tensor whose shape is
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with the first argument.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to compare
|
|||
|
|
other (Tensor or float): the tensor or value to compare
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A boolean tensor that is True where :attr:`input` is greater than :attr:`other` and False elsewhere
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.gt(torch.tensor([[1, 2], [3, 4]]), torch.tensor([[1, 1], [4, 4]]))
|
|||
|
|
tensor([[False, True], [False, False]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def hamming_window(window_length: _int, *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
hamming_window(window_length, periodic=True, alpha=0.54, beta=0.46, *, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Hamming window function.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
w[n] = \alpha - \beta\ \cos \left( \frac{2 \pi n}{N - 1} \right),
|
|||
|
|
|
|||
|
|
where :math:`N` is the full window size.
|
|||
|
|
|
|||
|
|
The input :attr:`window_length` is a positive integer controlling the
|
|||
|
|
returned window size. :attr:`periodic` flag determines whether the returned
|
|||
|
|
window trims off the last duplicate value from the symmetric window and is
|
|||
|
|
ready to be used as a periodic window with functions like
|
|||
|
|
:meth:`torch.stft`. Therefore, if :attr:`periodic` is true, the :math:`N` in
|
|||
|
|
above formula is in fact :math:`\text{window\_length} + 1`. Also, we always have
|
|||
|
|
``torch.hamming_window(L, periodic=True)`` equal to
|
|||
|
|
``torch.hamming_window(L + 1, periodic=False)[:-1])``.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If :attr:`window_length` :math:`=1`, the returned window contains a single value 1.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
This is a generalized version of :meth:`torch.hann_window`.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
window_length (int): the size of returned window
|
|||
|
|
periodic (bool, optional): If True, returns a window to be used as periodic
|
|||
|
|
function. If False, return a symmetric window.
|
|||
|
|
alpha (float, optional): The coefficient :math:`\alpha` in the equation above
|
|||
|
|
beta (float, optional): The coefficient :math:`\beta` in the equation above
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`). Only floating point types are supported.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned window tensor. Only
|
|||
|
|
``torch.strided`` (dense layout) is supported.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A 1-D tensor of size :math:`(\text{window\_length},)` containing the window.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def hamming_window(window_length: _int, periodic: _bool, *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
hamming_window(window_length, periodic=True, alpha=0.54, beta=0.46, *, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Hamming window function.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
w[n] = \alpha - \beta\ \cos \left( \frac{2 \pi n}{N - 1} \right),
|
|||
|
|
|
|||
|
|
where :math:`N` is the full window size.
|
|||
|
|
|
|||
|
|
The input :attr:`window_length` is a positive integer controlling the
|
|||
|
|
returned window size. :attr:`periodic` flag determines whether the returned
|
|||
|
|
window trims off the last duplicate value from the symmetric window and is
|
|||
|
|
ready to be used as a periodic window with functions like
|
|||
|
|
:meth:`torch.stft`. Therefore, if :attr:`periodic` is true, the :math:`N` in
|
|||
|
|
above formula is in fact :math:`\text{window\_length} + 1`. Also, we always have
|
|||
|
|
``torch.hamming_window(L, periodic=True)`` equal to
|
|||
|
|
``torch.hamming_window(L + 1, periodic=False)[:-1])``.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If :attr:`window_length` :math:`=1`, the returned window contains a single value 1.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
This is a generalized version of :meth:`torch.hann_window`.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
window_length (int): the size of returned window
|
|||
|
|
periodic (bool, optional): If True, returns a window to be used as periodic
|
|||
|
|
function. If False, return a symmetric window.
|
|||
|
|
alpha (float, optional): The coefficient :math:`\alpha` in the equation above
|
|||
|
|
beta (float, optional): The coefficient :math:`\beta` in the equation above
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`). Only floating point types are supported.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned window tensor. Only
|
|||
|
|
``torch.strided`` (dense layout) is supported.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A 1-D tensor of size :math:`(\text{window\_length},)` containing the window.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def hamming_window(window_length: _int, periodic: _bool, alpha: _float, *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
hamming_window(window_length, periodic=True, alpha=0.54, beta=0.46, *, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Hamming window function.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
w[n] = \alpha - \beta\ \cos \left( \frac{2 \pi n}{N - 1} \right),
|
|||
|
|
|
|||
|
|
where :math:`N` is the full window size.
|
|||
|
|
|
|||
|
|
The input :attr:`window_length` is a positive integer controlling the
|
|||
|
|
returned window size. :attr:`periodic` flag determines whether the returned
|
|||
|
|
window trims off the last duplicate value from the symmetric window and is
|
|||
|
|
ready to be used as a periodic window with functions like
|
|||
|
|
:meth:`torch.stft`. Therefore, if :attr:`periodic` is true, the :math:`N` in
|
|||
|
|
above formula is in fact :math:`\text{window\_length} + 1`. Also, we always have
|
|||
|
|
``torch.hamming_window(L, periodic=True)`` equal to
|
|||
|
|
``torch.hamming_window(L + 1, periodic=False)[:-1])``.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If :attr:`window_length` :math:`=1`, the returned window contains a single value 1.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
This is a generalized version of :meth:`torch.hann_window`.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
window_length (int): the size of returned window
|
|||
|
|
periodic (bool, optional): If True, returns a window to be used as periodic
|
|||
|
|
function. If False, return a symmetric window.
|
|||
|
|
alpha (float, optional): The coefficient :math:`\alpha` in the equation above
|
|||
|
|
beta (float, optional): The coefficient :math:`\beta` in the equation above
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`). Only floating point types are supported.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned window tensor. Only
|
|||
|
|
``torch.strided`` (dense layout) is supported.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A 1-D tensor of size :math:`(\text{window\_length},)` containing the window.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def hamming_window(window_length: _int, periodic: _bool, alpha: _float, beta: _float, *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
hamming_window(window_length, periodic=True, alpha=0.54, beta=0.46, *, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Hamming window function.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
w[n] = \alpha - \beta\ \cos \left( \frac{2 \pi n}{N - 1} \right),
|
|||
|
|
|
|||
|
|
where :math:`N` is the full window size.
|
|||
|
|
|
|||
|
|
The input :attr:`window_length` is a positive integer controlling the
|
|||
|
|
returned window size. :attr:`periodic` flag determines whether the returned
|
|||
|
|
window trims off the last duplicate value from the symmetric window and is
|
|||
|
|
ready to be used as a periodic window with functions like
|
|||
|
|
:meth:`torch.stft`. Therefore, if :attr:`periodic` is true, the :math:`N` in
|
|||
|
|
above formula is in fact :math:`\text{window\_length} + 1`. Also, we always have
|
|||
|
|
``torch.hamming_window(L, periodic=True)`` equal to
|
|||
|
|
``torch.hamming_window(L + 1, periodic=False)[:-1])``.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If :attr:`window_length` :math:`=1`, the returned window contains a single value 1.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
This is a generalized version of :meth:`torch.hann_window`.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
window_length (int): the size of returned window
|
|||
|
|
periodic (bool, optional): If True, returns a window to be used as periodic
|
|||
|
|
function. If False, return a symmetric window.
|
|||
|
|
alpha (float, optional): The coefficient :math:`\alpha` in the equation above
|
|||
|
|
beta (float, optional): The coefficient :math:`\beta` in the equation above
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`). Only floating point types are supported.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned window tensor. Only
|
|||
|
|
``torch.strided`` (dense layout) is supported.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A 1-D tensor of size :math:`(\text{window\_length},)` containing the window.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def hann_window(window_length: _int, *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
hann_window(window_length, periodic=True, *, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Hann window function.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
w[n] = \frac{1}{2}\ \left[1 - \cos \left( \frac{2 \pi n}{N - 1} \right)\right] =
|
|||
|
|
\sin^2 \left( \frac{\pi n}{N - 1} \right),
|
|||
|
|
|
|||
|
|
where :math:`N` is the full window size.
|
|||
|
|
|
|||
|
|
The input :attr:`window_length` is a positive integer controlling the
|
|||
|
|
returned window size. :attr:`periodic` flag determines whether the returned
|
|||
|
|
window trims off the last duplicate value from the symmetric window and is
|
|||
|
|
ready to be used as a periodic window with functions like
|
|||
|
|
:meth:`torch.stft`. Therefore, if :attr:`periodic` is true, the :math:`N` in
|
|||
|
|
above formula is in fact :math:`\text{window\_length} + 1`. Also, we always have
|
|||
|
|
``torch.hann_window(L, periodic=True)`` equal to
|
|||
|
|
``torch.hann_window(L + 1, periodic=False)[:-1])``.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If :attr:`window_length` :math:`=1`, the returned window contains a single value 1.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
window_length (int): the size of returned window
|
|||
|
|
periodic (bool, optional): If True, returns a window to be used as periodic
|
|||
|
|
function. If False, return a symmetric window.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`). Only floating point types are supported.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned window tensor. Only
|
|||
|
|
``torch.strided`` (dense layout) is supported.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A 1-D tensor of size :math:`(\text{window\_length},)` containing the window
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def hann_window(window_length: _int, periodic: _bool, *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
hann_window(window_length, periodic=True, *, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Hann window function.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
w[n] = \frac{1}{2}\ \left[1 - \cos \left( \frac{2 \pi n}{N - 1} \right)\right] =
|
|||
|
|
\sin^2 \left( \frac{\pi n}{N - 1} \right),
|
|||
|
|
|
|||
|
|
where :math:`N` is the full window size.
|
|||
|
|
|
|||
|
|
The input :attr:`window_length` is a positive integer controlling the
|
|||
|
|
returned window size. :attr:`periodic` flag determines whether the returned
|
|||
|
|
window trims off the last duplicate value from the symmetric window and is
|
|||
|
|
ready to be used as a periodic window with functions like
|
|||
|
|
:meth:`torch.stft`. Therefore, if :attr:`periodic` is true, the :math:`N` in
|
|||
|
|
above formula is in fact :math:`\text{window\_length} + 1`. Also, we always have
|
|||
|
|
``torch.hann_window(L, periodic=True)`` equal to
|
|||
|
|
``torch.hann_window(L + 1, periodic=False)[:-1])``.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If :attr:`window_length` :math:`=1`, the returned window contains a single value 1.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
window_length (int): the size of returned window
|
|||
|
|
periodic (bool, optional): If True, returns a window to be used as periodic
|
|||
|
|
function. If False, return a symmetric window.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`). Only floating point types are supported.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned window tensor. Only
|
|||
|
|
``torch.strided`` (dense layout) is supported.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A 1-D tensor of size :math:`(\text{window\_length},)` containing the window
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def hardshrink(input: Tensor, lambd: Union[Number, _complex] = 0.5, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def heaviside(input: Tensor, values: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
heaviside(input, values, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the Heaviside step function for each element in :attr:`input`.
|
|||
|
|
The Heaviside step function is defined as:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{{heaviside}}(input, values) = \begin{cases}
|
|||
|
|
0, & \text{if input < 0}\\
|
|||
|
|
values, & \text{if input == 0}\\
|
|||
|
|
1, & \text{if input > 0}
|
|||
|
|
\end{cases}
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
values (Tensor): The values to use where :attr:`input` is zero.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> input = torch.tensor([-1.5, 0, 2.0])
|
|||
|
|
>>> values = torch.tensor([0.5])
|
|||
|
|
>>> torch.heaviside(input, values)
|
|||
|
|
tensor([0.0000, 0.5000, 1.0000])
|
|||
|
|
>>> values = torch.tensor([1.2, -2.0, 3.5])
|
|||
|
|
>>> torch.heaviside(input, values)
|
|||
|
|
tensor([0., -2., 1.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def hinge_embedding_loss(input: Tensor, target: Tensor, margin: _float = 1.0, reduction: _int = 1) -> Tensor: ...
|
|||
|
|
def histc(input: Tensor, bins: _int = 100, min: Union[Number, _complex] = 0, max: Union[Number, _complex] = 0, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
histc(input, bins=100, min=0, max=0, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the histogram of a tensor.
|
|||
|
|
|
|||
|
|
The elements are sorted into equal width bins between :attr:`min` and
|
|||
|
|
:attr:`max`. If :attr:`min` and :attr:`max` are both zero, the minimum and
|
|||
|
|
maximum values of the data are used.
|
|||
|
|
|
|||
|
|
Elements lower than min and higher than max and ``NaN`` elements are ignored.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
bins (int): number of histogram bins
|
|||
|
|
min (Scalar): lower end of the range (inclusive)
|
|||
|
|
max (Scalar): upper end of the range (inclusive)
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: Histogram represented as a tensor
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.histc(torch.tensor([1., 2, 1]), bins=4, min=0, max=3)
|
|||
|
|
tensor([ 0., 2., 1., 0.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def histogram(input: Tensor, bins: Tensor, *, weight: Optional[Tensor] = None, density: _bool = False, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.histogram:
|
|||
|
|
r"""
|
|||
|
|
histogram(input, bins, *, range=None, weight=None, density=False, out=None) -> (Tensor, Tensor)
|
|||
|
|
|
|||
|
|
Computes a histogram of the values in a tensor.
|
|||
|
|
|
|||
|
|
:attr:`bins` can be an integer or a 1D tensor.
|
|||
|
|
|
|||
|
|
If :attr:`bins` is an int, it specifies the number of equal-width bins.
|
|||
|
|
By default, the lower and upper range of the bins is determined by the
|
|||
|
|
minimum and maximum elements of the input tensor. The :attr:`range`
|
|||
|
|
argument can be provided to specify a range for the bins.
|
|||
|
|
|
|||
|
|
If :attr:`bins` is a 1D tensor, it specifies the sequence of bin edges
|
|||
|
|
including the rightmost edge. It should contain at least 2 elements
|
|||
|
|
and its elements should be increasing.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
bins: int or 1D Tensor. If int, defines the number of equal-width bins. If tensor,
|
|||
|
|
defines the sequence of bin edges including the rightmost edge.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
range (tuple of float): Defines the range of the bins.
|
|||
|
|
weight (Tensor): If provided, weight should have the same shape as input. Each value in
|
|||
|
|
input contributes its associated weight towards its bin's result.
|
|||
|
|
density (bool): If False, the result will contain the count (or total weight) in each bin.
|
|||
|
|
If True, the result is the value of the probability density function over the bins,
|
|||
|
|
normalized such that the integral over the range of the bins is 1.
|
|||
|
|
out (Tensor, optional): the output tensor. (tuple, optional): The result tuple of two output tensors (hist, bin_edges).
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
hist (Tensor): 1D Tensor containing the values of the histogram.
|
|||
|
|
bin_edges(Tensor): 1D Tensor containing the edges of the histogram bins.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.histogram(torch.tensor([1., 2, 1]), bins=4, range=(0., 3.), weight=torch.tensor([1., 2., 4.]))
|
|||
|
|
(tensor([ 0., 5., 2., 0.]), tensor([0., 0.75, 1.5, 2.25, 3.]))
|
|||
|
|
>>> torch.histogram(torch.tensor([1., 2, 1]), bins=4, range=(0., 3.), weight=torch.tensor([1., 2., 4.]), density=True)
|
|||
|
|
(tensor([ 0., 0.9524, 0.3810, 0.]), tensor([0., 0.75, 1.5, 2.25, 3.]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def histogram(input: Tensor, bins: _int = 100, *, range: Optional[Sequence[_float]] = None, weight: Optional[Tensor] = None, density: _bool = False, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.histogram:
|
|||
|
|
r"""
|
|||
|
|
histogram(input, bins, *, range=None, weight=None, density=False, out=None) -> (Tensor, Tensor)
|
|||
|
|
|
|||
|
|
Computes a histogram of the values in a tensor.
|
|||
|
|
|
|||
|
|
:attr:`bins` can be an integer or a 1D tensor.
|
|||
|
|
|
|||
|
|
If :attr:`bins` is an int, it specifies the number of equal-width bins.
|
|||
|
|
By default, the lower and upper range of the bins is determined by the
|
|||
|
|
minimum and maximum elements of the input tensor. The :attr:`range`
|
|||
|
|
argument can be provided to specify a range for the bins.
|
|||
|
|
|
|||
|
|
If :attr:`bins` is a 1D tensor, it specifies the sequence of bin edges
|
|||
|
|
including the rightmost edge. It should contain at least 2 elements
|
|||
|
|
and its elements should be increasing.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
bins: int or 1D Tensor. If int, defines the number of equal-width bins. If tensor,
|
|||
|
|
defines the sequence of bin edges including the rightmost edge.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
range (tuple of float): Defines the range of the bins.
|
|||
|
|
weight (Tensor): If provided, weight should have the same shape as input. Each value in
|
|||
|
|
input contributes its associated weight towards its bin's result.
|
|||
|
|
density (bool): If False, the result will contain the count (or total weight) in each bin.
|
|||
|
|
If True, the result is the value of the probability density function over the bins,
|
|||
|
|
normalized such that the integral over the range of the bins is 1.
|
|||
|
|
out (Tensor, optional): the output tensor. (tuple, optional): The result tuple of two output tensors (hist, bin_edges).
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
hist (Tensor): 1D Tensor containing the values of the histogram.
|
|||
|
|
bin_edges(Tensor): 1D Tensor containing the edges of the histogram bins.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.histogram(torch.tensor([1., 2, 1]), bins=4, range=(0., 3.), weight=torch.tensor([1., 2., 4.]))
|
|||
|
|
(tensor([ 0., 5., 2., 0.]), tensor([0., 0.75, 1.5, 2.25, 3.]))
|
|||
|
|
>>> torch.histogram(torch.tensor([1., 2, 1]), bins=4, range=(0., 3.), weight=torch.tensor([1., 2., 4.]), density=True)
|
|||
|
|
(tensor([ 0., 0.9524, 0.3810, 0.]), tensor([0., 0.75, 1.5, 2.25, 3.]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def histogramdd(input: Tensor, bins: _int, range: Optional[Sequence[_float]] = None, weight: Optional[Tensor] = None, density: _bool = False) -> torch.return_types.histogramdd:
|
|||
|
|
r"""
|
|||
|
|
histogramdd(input, bins, *, range=None, weight=None, density=False, out=None) -> (Tensor, Tensor[])
|
|||
|
|
|
|||
|
|
Computes a multi-dimensional histogram of the values in a tensor.
|
|||
|
|
|
|||
|
|
Interprets the elements of an input tensor whose innermost dimension has size N
|
|||
|
|
as a collection of N-dimensional points. Maps each of the points into a set of
|
|||
|
|
N-dimensional bins and returns the number of points (or total weight) in each bin.
|
|||
|
|
|
|||
|
|
:attr:`input` must be a tensor with at least 2 dimensions.
|
|||
|
|
If input has shape (M, N), each of its M rows defines a point in N-dimensional space.
|
|||
|
|
If input has three or more dimensions, all but the last dimension are flattened.
|
|||
|
|
|
|||
|
|
Each dimension is independently associated with its own strictly increasing sequence
|
|||
|
|
of bin edges. Bin edges may be specified explicitly by passing a sequence of 1D
|
|||
|
|
tensors. Alternatively, bin edges may be constructed automatically by passing a
|
|||
|
|
sequence of integers specifying the number of equal-width bins in each dimension.
|
|||
|
|
|
|||
|
|
For each N-dimensional point in input:
|
|||
|
|
- Each of its coordinates is binned independently among the bin edges
|
|||
|
|
corresponding to its dimension
|
|||
|
|
- Binning results are combined to identify the N-dimensional bin (if any)
|
|||
|
|
into which the point falls
|
|||
|
|
- If the point falls into a bin, the bin's count (or total weight) is incremented
|
|||
|
|
- Points which do not fall into any bin do not contribute to the output
|
|||
|
|
|
|||
|
|
:attr:`bins` can be a sequence of N 1D tensors, a sequence of N ints, or a single int.
|
|||
|
|
|
|||
|
|
If :attr:`bins` is a sequence of N 1D tensors, it explicitly specifies the N sequences
|
|||
|
|
of bin edges. Each 1D tensor should contain a strictly increasing sequence with at
|
|||
|
|
least one element. A sequence of K bin edges defines K-1 bins, explicitly specifying
|
|||
|
|
the left and right edges of all bins. Every bin is exclusive of its left edge. Only
|
|||
|
|
the rightmost bin is inclusive of its right edge.
|
|||
|
|
|
|||
|
|
If :attr:`bins` is a sequence of N ints, it specifies the number of equal-width bins
|
|||
|
|
in each dimension. By default, the leftmost and rightmost bin edges in each dimension
|
|||
|
|
are determined by the minimum and maximum elements of the input tensor in the
|
|||
|
|
corresponding dimension. The :attr:`range` argument can be provided to manually
|
|||
|
|
specify the leftmost and rightmost bin edges in each dimension.
|
|||
|
|
|
|||
|
|
If :attr:`bins` is an int, it specifies the number of equal-width bins for all dimensions.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
See also :func:`torch.histogram`, which specifically computes 1D histograms.
|
|||
|
|
While :func:`torch.histogramdd` infers the dimensionality of its bins and
|
|||
|
|
binned values from the shape of :attr:`input`, :func:`torch.histogram`
|
|||
|
|
accepts and flattens :attr:`input` of any shape.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
bins: Tensor[], int[], or int.
|
|||
|
|
If Tensor[], defines the sequences of bin edges.
|
|||
|
|
If int[], defines the number of equal-width bins in each dimension.
|
|||
|
|
If int, defines the number of equal-width bins for all dimensions.
|
|||
|
|
Keyword args:
|
|||
|
|
range (sequence of float): Defines the leftmost and rightmost bin edges
|
|||
|
|
in each dimension.
|
|||
|
|
weight (Tensor): By default, each value in the input has weight 1. If a weight
|
|||
|
|
tensor is passed, each N-dimensional coordinate in input
|
|||
|
|
contributes its associated weight towards its bin's result.
|
|||
|
|
The weight tensor should have the same shape as the :attr:`input`
|
|||
|
|
tensor excluding its innermost dimension N.
|
|||
|
|
density (bool): If False (default), the result will contain the count (or total weight)
|
|||
|
|
in each bin. If True, each count (weight) is divided by the total count
|
|||
|
|
(total weight), then divided by the volume of its associated bin.
|
|||
|
|
Returns:
|
|||
|
|
hist (Tensor): N-dimensional Tensor containing the values of the histogram.
|
|||
|
|
bin_edges(Tensor[]): sequence of N 1D Tensors containing the bin edges.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
>>> torch.histogramdd(torch.tensor([[0., 1.], [1., 0.], [2., 0.], [2., 2.]]), bins=[3, 3],
|
|||
|
|
... weight=torch.tensor([1., 2., 4., 8.]))
|
|||
|
|
torch.return_types.histogramdd(
|
|||
|
|
hist=tensor([[0., 1., 0.],
|
|||
|
|
[2., 0., 0.],
|
|||
|
|
[4., 0., 8.]]),
|
|||
|
|
bin_edges=(tensor([0.0000, 0.6667, 1.3333, 2.0000]),
|
|||
|
|
tensor([0.0000, 0.6667, 1.3333, 2.0000])))
|
|||
|
|
|
|||
|
|
>>> torch.histogramdd(torch.tensor([[0., 0.], [1., 1.], [2., 2.]]), bins=[2, 2],
|
|||
|
|
... range=[0., 1., 0., 1.], density=True)
|
|||
|
|
torch.return_types.histogramdd(
|
|||
|
|
hist=tensor([[2., 0.],
|
|||
|
|
[0., 2.]]),
|
|||
|
|
bin_edges=(tensor([0.0000, 0.5000, 1.0000]),
|
|||
|
|
tensor([0.0000, 0.5000, 1.0000])))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def histogramdd(input: Tensor, bins: _size, range: Optional[Sequence[_float]] = None, weight: Optional[Tensor] = None, density: _bool = False) -> torch.return_types.histogramdd:
|
|||
|
|
r"""
|
|||
|
|
histogramdd(input, bins, *, range=None, weight=None, density=False, out=None) -> (Tensor, Tensor[])
|
|||
|
|
|
|||
|
|
Computes a multi-dimensional histogram of the values in a tensor.
|
|||
|
|
|
|||
|
|
Interprets the elements of an input tensor whose innermost dimension has size N
|
|||
|
|
as a collection of N-dimensional points. Maps each of the points into a set of
|
|||
|
|
N-dimensional bins and returns the number of points (or total weight) in each bin.
|
|||
|
|
|
|||
|
|
:attr:`input` must be a tensor with at least 2 dimensions.
|
|||
|
|
If input has shape (M, N), each of its M rows defines a point in N-dimensional space.
|
|||
|
|
If input has three or more dimensions, all but the last dimension are flattened.
|
|||
|
|
|
|||
|
|
Each dimension is independently associated with its own strictly increasing sequence
|
|||
|
|
of bin edges. Bin edges may be specified explicitly by passing a sequence of 1D
|
|||
|
|
tensors. Alternatively, bin edges may be constructed automatically by passing a
|
|||
|
|
sequence of integers specifying the number of equal-width bins in each dimension.
|
|||
|
|
|
|||
|
|
For each N-dimensional point in input:
|
|||
|
|
- Each of its coordinates is binned independently among the bin edges
|
|||
|
|
corresponding to its dimension
|
|||
|
|
- Binning results are combined to identify the N-dimensional bin (if any)
|
|||
|
|
into which the point falls
|
|||
|
|
- If the point falls into a bin, the bin's count (or total weight) is incremented
|
|||
|
|
- Points which do not fall into any bin do not contribute to the output
|
|||
|
|
|
|||
|
|
:attr:`bins` can be a sequence of N 1D tensors, a sequence of N ints, or a single int.
|
|||
|
|
|
|||
|
|
If :attr:`bins` is a sequence of N 1D tensors, it explicitly specifies the N sequences
|
|||
|
|
of bin edges. Each 1D tensor should contain a strictly increasing sequence with at
|
|||
|
|
least one element. A sequence of K bin edges defines K-1 bins, explicitly specifying
|
|||
|
|
the left and right edges of all bins. Every bin is exclusive of its left edge. Only
|
|||
|
|
the rightmost bin is inclusive of its right edge.
|
|||
|
|
|
|||
|
|
If :attr:`bins` is a sequence of N ints, it specifies the number of equal-width bins
|
|||
|
|
in each dimension. By default, the leftmost and rightmost bin edges in each dimension
|
|||
|
|
are determined by the minimum and maximum elements of the input tensor in the
|
|||
|
|
corresponding dimension. The :attr:`range` argument can be provided to manually
|
|||
|
|
specify the leftmost and rightmost bin edges in each dimension.
|
|||
|
|
|
|||
|
|
If :attr:`bins` is an int, it specifies the number of equal-width bins for all dimensions.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
See also :func:`torch.histogram`, which specifically computes 1D histograms.
|
|||
|
|
While :func:`torch.histogramdd` infers the dimensionality of its bins and
|
|||
|
|
binned values from the shape of :attr:`input`, :func:`torch.histogram`
|
|||
|
|
accepts and flattens :attr:`input` of any shape.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
bins: Tensor[], int[], or int.
|
|||
|
|
If Tensor[], defines the sequences of bin edges.
|
|||
|
|
If int[], defines the number of equal-width bins in each dimension.
|
|||
|
|
If int, defines the number of equal-width bins for all dimensions.
|
|||
|
|
Keyword args:
|
|||
|
|
range (sequence of float): Defines the leftmost and rightmost bin edges
|
|||
|
|
in each dimension.
|
|||
|
|
weight (Tensor): By default, each value in the input has weight 1. If a weight
|
|||
|
|
tensor is passed, each N-dimensional coordinate in input
|
|||
|
|
contributes its associated weight towards its bin's result.
|
|||
|
|
The weight tensor should have the same shape as the :attr:`input`
|
|||
|
|
tensor excluding its innermost dimension N.
|
|||
|
|
density (bool): If False (default), the result will contain the count (or total weight)
|
|||
|
|
in each bin. If True, each count (weight) is divided by the total count
|
|||
|
|
(total weight), then divided by the volume of its associated bin.
|
|||
|
|
Returns:
|
|||
|
|
hist (Tensor): N-dimensional Tensor containing the values of the histogram.
|
|||
|
|
bin_edges(Tensor[]): sequence of N 1D Tensors containing the bin edges.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
>>> torch.histogramdd(torch.tensor([[0., 1.], [1., 0.], [2., 0.], [2., 2.]]), bins=[3, 3],
|
|||
|
|
... weight=torch.tensor([1., 2., 4., 8.]))
|
|||
|
|
torch.return_types.histogramdd(
|
|||
|
|
hist=tensor([[0., 1., 0.],
|
|||
|
|
[2., 0., 0.],
|
|||
|
|
[4., 0., 8.]]),
|
|||
|
|
bin_edges=(tensor([0.0000, 0.6667, 1.3333, 2.0000]),
|
|||
|
|
tensor([0.0000, 0.6667, 1.3333, 2.0000])))
|
|||
|
|
|
|||
|
|
>>> torch.histogramdd(torch.tensor([[0., 0.], [1., 1.], [2., 2.]]), bins=[2, 2],
|
|||
|
|
... range=[0., 1., 0., 1.], density=True)
|
|||
|
|
torch.return_types.histogramdd(
|
|||
|
|
hist=tensor([[2., 0.],
|
|||
|
|
[0., 2.]]),
|
|||
|
|
bin_edges=(tensor([0.0000, 0.5000, 1.0000]),
|
|||
|
|
tensor([0.0000, 0.5000, 1.0000])))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def histogramdd(input: Tensor, bins: Union[Tuple[Tensor, ...], List[Tensor]], range: Optional[Sequence[_float]] = None, weight: Optional[Tensor] = None, density: _bool = False) -> torch.return_types.histogramdd:
|
|||
|
|
r"""
|
|||
|
|
histogramdd(input, bins, *, range=None, weight=None, density=False, out=None) -> (Tensor, Tensor[])
|
|||
|
|
|
|||
|
|
Computes a multi-dimensional histogram of the values in a tensor.
|
|||
|
|
|
|||
|
|
Interprets the elements of an input tensor whose innermost dimension has size N
|
|||
|
|
as a collection of N-dimensional points. Maps each of the points into a set of
|
|||
|
|
N-dimensional bins and returns the number of points (or total weight) in each bin.
|
|||
|
|
|
|||
|
|
:attr:`input` must be a tensor with at least 2 dimensions.
|
|||
|
|
If input has shape (M, N), each of its M rows defines a point in N-dimensional space.
|
|||
|
|
If input has three or more dimensions, all but the last dimension are flattened.
|
|||
|
|
|
|||
|
|
Each dimension is independently associated with its own strictly increasing sequence
|
|||
|
|
of bin edges. Bin edges may be specified explicitly by passing a sequence of 1D
|
|||
|
|
tensors. Alternatively, bin edges may be constructed automatically by passing a
|
|||
|
|
sequence of integers specifying the number of equal-width bins in each dimension.
|
|||
|
|
|
|||
|
|
For each N-dimensional point in input:
|
|||
|
|
- Each of its coordinates is binned independently among the bin edges
|
|||
|
|
corresponding to its dimension
|
|||
|
|
- Binning results are combined to identify the N-dimensional bin (if any)
|
|||
|
|
into which the point falls
|
|||
|
|
- If the point falls into a bin, the bin's count (or total weight) is incremented
|
|||
|
|
- Points which do not fall into any bin do not contribute to the output
|
|||
|
|
|
|||
|
|
:attr:`bins` can be a sequence of N 1D tensors, a sequence of N ints, or a single int.
|
|||
|
|
|
|||
|
|
If :attr:`bins` is a sequence of N 1D tensors, it explicitly specifies the N sequences
|
|||
|
|
of bin edges. Each 1D tensor should contain a strictly increasing sequence with at
|
|||
|
|
least one element. A sequence of K bin edges defines K-1 bins, explicitly specifying
|
|||
|
|
the left and right edges of all bins. Every bin is exclusive of its left edge. Only
|
|||
|
|
the rightmost bin is inclusive of its right edge.
|
|||
|
|
|
|||
|
|
If :attr:`bins` is a sequence of N ints, it specifies the number of equal-width bins
|
|||
|
|
in each dimension. By default, the leftmost and rightmost bin edges in each dimension
|
|||
|
|
are determined by the minimum and maximum elements of the input tensor in the
|
|||
|
|
corresponding dimension. The :attr:`range` argument can be provided to manually
|
|||
|
|
specify the leftmost and rightmost bin edges in each dimension.
|
|||
|
|
|
|||
|
|
If :attr:`bins` is an int, it specifies the number of equal-width bins for all dimensions.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
See also :func:`torch.histogram`, which specifically computes 1D histograms.
|
|||
|
|
While :func:`torch.histogramdd` infers the dimensionality of its bins and
|
|||
|
|
binned values from the shape of :attr:`input`, :func:`torch.histogram`
|
|||
|
|
accepts and flattens :attr:`input` of any shape.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
bins: Tensor[], int[], or int.
|
|||
|
|
If Tensor[], defines the sequences of bin edges.
|
|||
|
|
If int[], defines the number of equal-width bins in each dimension.
|
|||
|
|
If int, defines the number of equal-width bins for all dimensions.
|
|||
|
|
Keyword args:
|
|||
|
|
range (sequence of float): Defines the leftmost and rightmost bin edges
|
|||
|
|
in each dimension.
|
|||
|
|
weight (Tensor): By default, each value in the input has weight 1. If a weight
|
|||
|
|
tensor is passed, each N-dimensional coordinate in input
|
|||
|
|
contributes its associated weight towards its bin's result.
|
|||
|
|
The weight tensor should have the same shape as the :attr:`input`
|
|||
|
|
tensor excluding its innermost dimension N.
|
|||
|
|
density (bool): If False (default), the result will contain the count (or total weight)
|
|||
|
|
in each bin. If True, each count (weight) is divided by the total count
|
|||
|
|
(total weight), then divided by the volume of its associated bin.
|
|||
|
|
Returns:
|
|||
|
|
hist (Tensor): N-dimensional Tensor containing the values of the histogram.
|
|||
|
|
bin_edges(Tensor[]): sequence of N 1D Tensors containing the bin edges.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
>>> torch.histogramdd(torch.tensor([[0., 1.], [1., 0.], [2., 0.], [2., 2.]]), bins=[3, 3],
|
|||
|
|
... weight=torch.tensor([1., 2., 4., 8.]))
|
|||
|
|
torch.return_types.histogramdd(
|
|||
|
|
hist=tensor([[0., 1., 0.],
|
|||
|
|
[2., 0., 0.],
|
|||
|
|
[4., 0., 8.]]),
|
|||
|
|
bin_edges=(tensor([0.0000, 0.6667, 1.3333, 2.0000]),
|
|||
|
|
tensor([0.0000, 0.6667, 1.3333, 2.0000])))
|
|||
|
|
|
|||
|
|
>>> torch.histogramdd(torch.tensor([[0., 0.], [1., 1.], [2., 2.]]), bins=[2, 2],
|
|||
|
|
... range=[0., 1., 0., 1.], density=True)
|
|||
|
|
torch.return_types.histogramdd(
|
|||
|
|
hist=tensor([[2., 0.],
|
|||
|
|
[0., 2.]]),
|
|||
|
|
bin_edges=(tensor([0.0000, 0.5000, 1.0000]),
|
|||
|
|
tensor([0.0000, 0.5000, 1.0000])))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def hsmm(input: Tensor, mat2: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def hsplit(input: Tensor, sections: _int) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
hsplit(input, indices_or_sections) -> List of Tensors
|
|||
|
|
|
|||
|
|
Splits :attr:`input`, a tensor with one or more dimensions, into multiple tensors
|
|||
|
|
horizontally according to :attr:`indices_or_sections`. Each split is a view of
|
|||
|
|
:attr:`input`.
|
|||
|
|
|
|||
|
|
If :attr:`input` is one dimensional this is equivalent to calling
|
|||
|
|
torch.tensor_split(input, indices_or_sections, dim=0) (the split dimension is
|
|||
|
|
zero), and if :attr:`input` has two or more dimensions it's equivalent to calling
|
|||
|
|
torch.tensor_split(input, indices_or_sections, dim=1) (the split dimension is 1),
|
|||
|
|
except that if :attr:`indices_or_sections` is an integer it must evenly divide
|
|||
|
|
the split dimension or a runtime error will be thrown.
|
|||
|
|
|
|||
|
|
This function is based on NumPy's :func:`numpy.hsplit`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): tensor to split.
|
|||
|
|
indices_or_sections (int or list or tuple of ints): See argument in :func:`torch.tensor_split`.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
>>> t = torch.arange(16.0).reshape(4,4)
|
|||
|
|
>>> t
|
|||
|
|
tensor([[ 0., 1., 2., 3.],
|
|||
|
|
[ 4., 5., 6., 7.],
|
|||
|
|
[ 8., 9., 10., 11.],
|
|||
|
|
[12., 13., 14., 15.]])
|
|||
|
|
>>> torch.hsplit(t, 2)
|
|||
|
|
(tensor([[ 0., 1.],
|
|||
|
|
[ 4., 5.],
|
|||
|
|
[ 8., 9.],
|
|||
|
|
[12., 13.]]),
|
|||
|
|
tensor([[ 2., 3.],
|
|||
|
|
[ 6., 7.],
|
|||
|
|
[10., 11.],
|
|||
|
|
[14., 15.]]))
|
|||
|
|
>>> torch.hsplit(t, [3, 6])
|
|||
|
|
(tensor([[ 0., 1., 2.],
|
|||
|
|
[ 4., 5., 6.],
|
|||
|
|
[ 8., 9., 10.],
|
|||
|
|
[12., 13., 14.]]),
|
|||
|
|
tensor([[ 3.],
|
|||
|
|
[ 7.],
|
|||
|
|
[11.],
|
|||
|
|
[15.]]),
|
|||
|
|
tensor([], size=(4, 0)))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def hsplit(input: Tensor, indices: _size) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
hsplit(input, indices_or_sections) -> List of Tensors
|
|||
|
|
|
|||
|
|
Splits :attr:`input`, a tensor with one or more dimensions, into multiple tensors
|
|||
|
|
horizontally according to :attr:`indices_or_sections`. Each split is a view of
|
|||
|
|
:attr:`input`.
|
|||
|
|
|
|||
|
|
If :attr:`input` is one dimensional this is equivalent to calling
|
|||
|
|
torch.tensor_split(input, indices_or_sections, dim=0) (the split dimension is
|
|||
|
|
zero), and if :attr:`input` has two or more dimensions it's equivalent to calling
|
|||
|
|
torch.tensor_split(input, indices_or_sections, dim=1) (the split dimension is 1),
|
|||
|
|
except that if :attr:`indices_or_sections` is an integer it must evenly divide
|
|||
|
|
the split dimension or a runtime error will be thrown.
|
|||
|
|
|
|||
|
|
This function is based on NumPy's :func:`numpy.hsplit`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): tensor to split.
|
|||
|
|
indices_or_sections (int or list or tuple of ints): See argument in :func:`torch.tensor_split`.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
>>> t = torch.arange(16.0).reshape(4,4)
|
|||
|
|
>>> t
|
|||
|
|
tensor([[ 0., 1., 2., 3.],
|
|||
|
|
[ 4., 5., 6., 7.],
|
|||
|
|
[ 8., 9., 10., 11.],
|
|||
|
|
[12., 13., 14., 15.]])
|
|||
|
|
>>> torch.hsplit(t, 2)
|
|||
|
|
(tensor([[ 0., 1.],
|
|||
|
|
[ 4., 5.],
|
|||
|
|
[ 8., 9.],
|
|||
|
|
[12., 13.]]),
|
|||
|
|
tensor([[ 2., 3.],
|
|||
|
|
[ 6., 7.],
|
|||
|
|
[10., 11.],
|
|||
|
|
[14., 15.]]))
|
|||
|
|
>>> torch.hsplit(t, [3, 6])
|
|||
|
|
(tensor([[ 0., 1., 2.],
|
|||
|
|
[ 4., 5., 6.],
|
|||
|
|
[ 8., 9., 10.],
|
|||
|
|
[12., 13., 14.]]),
|
|||
|
|
tensor([[ 3.],
|
|||
|
|
[ 7.],
|
|||
|
|
[11.],
|
|||
|
|
[15.]]),
|
|||
|
|
tensor([], size=(4, 0)))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def hspmm(mat1: Tensor, mat2: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
hspmm(mat1, mat2, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a matrix multiplication of a :ref:`sparse COO matrix
|
|||
|
|
<sparse-coo-docs>` :attr:`mat1` and a strided matrix :attr:`mat2`. The
|
|||
|
|
result is a (1 + 1)-dimensional :ref:`hybrid COO matrix
|
|||
|
|
<sparse-hybrid-coo-docs>`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
mat1 (Tensor): the first sparse matrix to be matrix multiplied
|
|||
|
|
mat2 (Tensor): the second strided matrix to be matrix multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def hstack(tensors: Union[Tuple[Tensor, ...], List[Tensor]], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
hstack(tensors, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Stack tensors in sequence horizontally (column wise).
|
|||
|
|
|
|||
|
|
This is equivalent to concatenation along the first axis for 1-D tensors, and along the second axis for all other tensors.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
tensors (sequence of Tensors): sequence of tensors to concatenate
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([1, 2, 3])
|
|||
|
|
>>> b = torch.tensor([4, 5, 6])
|
|||
|
|
>>> torch.hstack((a,b))
|
|||
|
|
tensor([1, 2, 3, 4, 5, 6])
|
|||
|
|
>>> a = torch.tensor([[1],[2],[3]])
|
|||
|
|
>>> b = torch.tensor([[4],[5],[6]])
|
|||
|
|
>>> torch.hstack((a,b))
|
|||
|
|
tensor([[1, 4],
|
|||
|
|
[2, 5],
|
|||
|
|
[3, 6]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def hypot(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
hypot(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Given the legs of a right triangle, return its hypotenuse.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \sqrt{\text{input}_{i}^{2} + \text{other}_{i}^{2}}
|
|||
|
|
|
|||
|
|
The shapes of ``input`` and ``other`` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the first input tensor
|
|||
|
|
other (Tensor): the second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.hypot(torch.tensor([4.0]), torch.tensor([3.0, 4.0, 5.0]))
|
|||
|
|
tensor([5.0000, 5.6569, 6.4031])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def i0(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
i0(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.special.i0`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def i0_(input: Tensor) -> Tensor: ...
|
|||
|
|
def igamma(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
igamma(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.special.gammainc`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def igammac(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
igammac(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.special.gammaincc`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def imag(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
imag(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor containing imaginary values of the :attr:`self` tensor.
|
|||
|
|
The returned tensor and :attr:`self` share the same underlying storage.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
:func:`imag` is only supported for tensors with complex dtypes.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x=torch.randn(4, dtype=torch.cfloat)
|
|||
|
|
>>> x
|
|||
|
|
tensor([(0.3100+0.3553j), (-0.5445-0.7896j), (-1.6492-0.0633j), (-0.0638-0.8119j)])
|
|||
|
|
>>> x.imag
|
|||
|
|
tensor([ 0.3553, -0.7896, -0.0633, -0.8119])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def index_add(input: Tensor, dim: _int, index: Tensor, source: Tensor, *, alpha: Union[Number, _complex] = 1, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
index_add(input, dim, index, source, *, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
See :meth:`~Tensor.index_add_` for function description.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def index_add(input: Tensor, dim: Union[str, ellipsis, None], index: Tensor, source: Tensor, *, alpha: Union[Number, _complex] = 1) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
index_add(input, dim, index, source, *, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
See :meth:`~Tensor.index_add_` for function description.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def index_copy(input: Tensor, dim: _int, index: Tensor, source: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
index_copy(input, dim, index, source, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
See :meth:`~Tensor.index_add_` for function description.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def index_copy(input: Tensor, dim: Union[str, ellipsis, None], index: Tensor, source: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
index_copy(input, dim, index, source, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
See :meth:`~Tensor.index_add_` for function description.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def index_fill(input: Tensor, dim: _int, index: Tensor, value: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def index_fill(input: Tensor, dim: Union[str, ellipsis, None], index: Tensor, value: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def index_fill(input: Tensor, dim: _int, index: Tensor, value: Union[Number, _complex]) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def index_fill(input: Tensor, dim: Union[str, ellipsis, None], index: Tensor, value: Union[Number, _complex]) -> Tensor: ...
|
|||
|
|
def index_put(input: Tensor, indices: Optional[Union[Tuple[Tensor, ...], List[Tensor]]], values: Tensor, accumulate: _bool = False) -> Tensor: ...
|
|||
|
|
def index_put_(input: Tensor, indices: Optional[Union[Tuple[Tensor, ...], List[Tensor]]], values: Tensor, accumulate: _bool = False) -> Tensor: ...
|
|||
|
|
def index_reduce(input: Tensor, dim: _int, index: Tensor, source: Tensor, reduce: str, *, include_self: _bool = True, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
index_reduce(input, dim, index, source, reduce, *, include_self=True, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
See :meth:`~Tensor.index_reduce_` for function description.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def index_select(input: Tensor, dim: _int, index: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
index_select(input, dim, index, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor which indexes the :attr:`input` tensor along dimension
|
|||
|
|
:attr:`dim` using the entries in :attr:`index` which is a `LongTensor`.
|
|||
|
|
|
|||
|
|
The returned tensor has the same number of dimensions as the original tensor
|
|||
|
|
(:attr:`input`). The :attr:`dim`\ th dimension has the same size as the length
|
|||
|
|
of :attr:`index`; other dimensions have the same size as in the original tensor.
|
|||
|
|
|
|||
|
|
.. note:: The returned tensor does **not** use the same storage as the original
|
|||
|
|
tensor. If :attr:`out` has a different shape than expected, we
|
|||
|
|
silently change it to the correct shape, reallocating the underlying
|
|||
|
|
storage if necessary.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension in which we index
|
|||
|
|
index (IntTensor or LongTensor): the 1-D tensor containing the indices to index
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(3, 4)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 0.1427, 0.0231, -0.5414, -1.0009],
|
|||
|
|
[-0.4664, 0.2647, -0.1228, -1.1068],
|
|||
|
|
[-1.1734, -0.6571, 0.7230, -0.6004]])
|
|||
|
|
>>> indices = torch.tensor([0, 2])
|
|||
|
|
>>> torch.index_select(x, 0, indices)
|
|||
|
|
tensor([[ 0.1427, 0.0231, -0.5414, -1.0009],
|
|||
|
|
[-1.1734, -0.6571, 0.7230, -0.6004]])
|
|||
|
|
>>> torch.index_select(x, 1, indices)
|
|||
|
|
tensor([[ 0.1427, -0.5414],
|
|||
|
|
[-0.4664, -0.1228],
|
|||
|
|
[-1.1734, 0.7230]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def index_select(input: Tensor, dim: Union[str, ellipsis, None], index: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
index_select(input, dim, index, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor which indexes the :attr:`input` tensor along dimension
|
|||
|
|
:attr:`dim` using the entries in :attr:`index` which is a `LongTensor`.
|
|||
|
|
|
|||
|
|
The returned tensor has the same number of dimensions as the original tensor
|
|||
|
|
(:attr:`input`). The :attr:`dim`\ th dimension has the same size as the length
|
|||
|
|
of :attr:`index`; other dimensions have the same size as in the original tensor.
|
|||
|
|
|
|||
|
|
.. note:: The returned tensor does **not** use the same storage as the original
|
|||
|
|
tensor. If :attr:`out` has a different shape than expected, we
|
|||
|
|
silently change it to the correct shape, reallocating the underlying
|
|||
|
|
storage if necessary.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension in which we index
|
|||
|
|
index (IntTensor or LongTensor): the 1-D tensor containing the indices to index
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(3, 4)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 0.1427, 0.0231, -0.5414, -1.0009],
|
|||
|
|
[-0.4664, 0.2647, -0.1228, -1.1068],
|
|||
|
|
[-1.1734, -0.6571, 0.7230, -0.6004]])
|
|||
|
|
>>> indices = torch.tensor([0, 2])
|
|||
|
|
>>> torch.index_select(x, 0, indices)
|
|||
|
|
tensor([[ 0.1427, 0.0231, -0.5414, -1.0009],
|
|||
|
|
[-1.1734, -0.6571, 0.7230, -0.6004]])
|
|||
|
|
>>> torch.index_select(x, 1, indices)
|
|||
|
|
tensor([[ 0.1427, -0.5414],
|
|||
|
|
[-0.4664, -0.1228],
|
|||
|
|
[-1.1734, 0.7230]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def indices_copy(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.indices`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def init_num_threads() -> None: ...
|
|||
|
|
def inner(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
inner(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the dot product for 1D tensors. For higher dimensions, sums the product
|
|||
|
|
of elements from :attr:`input` and :attr:`other` along their last dimension.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
If either :attr:`input` or :attr:`other` is a scalar, the result is equivalent
|
|||
|
|
to `torch.mul(input, other)`.
|
|||
|
|
|
|||
|
|
If both :attr:`input` and :attr:`other` are non-scalars, the size of their last
|
|||
|
|
dimension must match and the result is equivalent to `torch.tensordot(input,
|
|||
|
|
other, dims=([-1], [-1]))`
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): First input tensor
|
|||
|
|
other (Tensor): Second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): Optional output tensor to write result into. The output
|
|||
|
|
shape is `input.shape[:-1] + other.shape[:-1]`.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
# Dot product
|
|||
|
|
>>> torch.inner(torch.tensor([1, 2, 3]), torch.tensor([0, 2, 1]))
|
|||
|
|
tensor(7)
|
|||
|
|
|
|||
|
|
# Multidimensional input tensors
|
|||
|
|
>>> a = torch.randn(2, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[0.8173, 1.0874, 1.1784],
|
|||
|
|
[0.3279, 0.1234, 2.7894]])
|
|||
|
|
>>> b = torch.randn(2, 4, 3)
|
|||
|
|
>>> b
|
|||
|
|
tensor([[[-0.4682, -0.7159, 0.1506],
|
|||
|
|
[ 0.4034, -0.3657, 1.0387],
|
|||
|
|
[ 0.9892, -0.6684, 0.1774],
|
|||
|
|
[ 0.9482, 1.3261, 0.3917]],
|
|||
|
|
|
|||
|
|
[[ 0.4537, 0.7493, 1.1724],
|
|||
|
|
[ 0.2291, 0.5749, -0.2267],
|
|||
|
|
[-0.7920, 0.3607, -0.3701],
|
|||
|
|
[ 1.3666, -0.5850, -1.7242]]])
|
|||
|
|
>>> torch.inner(a, b)
|
|||
|
|
tensor([[[-0.9837, 1.1560, 0.2907, 2.6785],
|
|||
|
|
[ 2.5671, 0.5452, -0.6912, -1.5509]],
|
|||
|
|
|
|||
|
|
[[ 0.1782, 2.9843, 0.7366, 1.5672],
|
|||
|
|
[ 3.5115, -0.4864, -1.2476, -4.4337]]])
|
|||
|
|
|
|||
|
|
# Scalar input
|
|||
|
|
>>> torch.inner(a, torch.tensor(2))
|
|||
|
|
tensor([[1.6347, 2.1748, 2.3567],
|
|||
|
|
[0.6558, 0.2469, 5.5787]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def instance_norm(input: Tensor, weight: Optional[Tensor], bias: Optional[Tensor], running_mean: Optional[Tensor], running_var: Optional[Tensor], use_input_stats: _bool, momentum: _float, eps: _float, cudnn_enabled: _bool) -> Tensor: ...
|
|||
|
|
def int_repr(input: Tensor) -> Tensor: ...
|
|||
|
|
def inverse(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
inverse(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.linalg.inv`
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def is_complex(input: Tensor) -> _bool:
|
|||
|
|
r"""
|
|||
|
|
is_complex(input) -> (bool)
|
|||
|
|
|
|||
|
|
Returns True if the data type of :attr:`input` is a complex data type i.e.,
|
|||
|
|
one of ``torch.complex64``, and ``torch.complex128``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def is_conj(input: Tensor) -> _bool:
|
|||
|
|
r"""
|
|||
|
|
is_conj(input) -> (bool)
|
|||
|
|
|
|||
|
|
Returns True if the :attr:`input` is a conjugated tensor, i.e. its conjugate bit is set to `True`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def is_distributed(input: Tensor) -> _bool: ...
|
|||
|
|
def is_floating_point(input: Tensor) -> _bool:
|
|||
|
|
r"""
|
|||
|
|
is_floating_point(input) -> (bool)
|
|||
|
|
|
|||
|
|
Returns True if the data type of :attr:`input` is a floating point data type i.e.,
|
|||
|
|
one of ``torch.float64``, ``torch.float32``, ``torch.float16``, and ``torch.bfloat16``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def is_grad_enabled() -> _bool:
|
|||
|
|
r"""
|
|||
|
|
is_grad_enabled() -> (bool)
|
|||
|
|
|
|||
|
|
Returns True if grad mode is currently enabled.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def is_inference(input: Tensor) -> _bool:
|
|||
|
|
r"""
|
|||
|
|
is_inference(input) -> (bool)
|
|||
|
|
|
|||
|
|
Returns True if :attr:`input` is an inference tensor.
|
|||
|
|
|
|||
|
|
A non-view tensor is an inference tensor if and only if it was
|
|||
|
|
allocated during inference mode. A view tensor is an inference
|
|||
|
|
tensor if and only if the tensor it is a view of is an inference tensor.
|
|||
|
|
|
|||
|
|
For details on inference mode please see
|
|||
|
|
`Inference Mode <https://pytorch.org/cppdocs/notes/inference_mode.html>`_.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def is_inference_mode_enabled() -> _bool:
|
|||
|
|
r"""
|
|||
|
|
is_inference_mode_enabled() -> (bool)
|
|||
|
|
|
|||
|
|
Returns True if inference mode is currently enabled.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def is_neg(input: Tensor) -> _bool: ...
|
|||
|
|
def is_nonzero(input: Tensor) -> _bool:
|
|||
|
|
r"""
|
|||
|
|
is_nonzero(input) -> (bool)
|
|||
|
|
|
|||
|
|
Returns True if the :attr:`input` is a single element tensor which is not equal to zero
|
|||
|
|
after type conversions.
|
|||
|
|
i.e. not equal to ``torch.tensor([0.])`` or ``torch.tensor([0])`` or
|
|||
|
|
``torch.tensor([False])``.
|
|||
|
|
Throws a ``RuntimeError`` if ``torch.numel() != 1`` (even in case
|
|||
|
|
of sparse tensors).
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> torch.is_nonzero(torch.tensor([0.]))
|
|||
|
|
False
|
|||
|
|
>>> torch.is_nonzero(torch.tensor([1.5]))
|
|||
|
|
True
|
|||
|
|
>>> torch.is_nonzero(torch.tensor([False]))
|
|||
|
|
False
|
|||
|
|
>>> torch.is_nonzero(torch.tensor([3]))
|
|||
|
|
True
|
|||
|
|
>>> torch.is_nonzero(torch.tensor([1, 3, 5]))
|
|||
|
|
Traceback (most recent call last):
|
|||
|
|
...
|
|||
|
|
RuntimeError: bool value of Tensor with more than one value is ambiguous
|
|||
|
|
>>> torch.is_nonzero(torch.tensor([]))
|
|||
|
|
Traceback (most recent call last):
|
|||
|
|
...
|
|||
|
|
RuntimeError: bool value of Tensor with no values is ambiguous
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def is_same_size(input: Tensor, other: Tensor) -> _bool: ...
|
|||
|
|
def is_signed(input: Tensor) -> _bool: ...
|
|||
|
|
def is_vulkan_available() -> _bool: ...
|
|||
|
|
def isclose(input: Tensor, other: Tensor, rtol: _float = 1e-05, atol: _float = 1e-08, equal_nan: _bool = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
isclose(input, other, rtol=1e-05, atol=1e-08, equal_nan=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with boolean elements representing if each element of
|
|||
|
|
:attr:`input` is "close" to the corresponding element of :attr:`other`.
|
|||
|
|
Closeness is defined as:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\lvert \text{input} - \text{other} \rvert \leq \texttt{atol} + \texttt{rtol} \times \lvert \text{other} \rvert
|
|||
|
|
|
|||
|
|
|
|||
|
|
where :attr:`input` and :attr:`other` are finite. Where :attr:`input`
|
|||
|
|
and/or :attr:`other` are nonfinite they are close if and only if
|
|||
|
|
they are equal, with NaNs being considered equal to each other when
|
|||
|
|
:attr:`equal_nan` is True.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): first tensor to compare
|
|||
|
|
other (Tensor): second tensor to compare
|
|||
|
|
atol (float, optional): absolute tolerance. Default: 1e-08
|
|||
|
|
rtol (float, optional): relative tolerance. Default: 1e-05
|
|||
|
|
equal_nan (bool, optional): if ``True``, then two ``NaN`` s will be considered equal. Default: ``False``
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> torch.isclose(torch.tensor((1., 2, 3)), torch.tensor((1 + 1e-10, 3, 4)))
|
|||
|
|
tensor([ True, False, False])
|
|||
|
|
>>> torch.isclose(torch.tensor((float('inf'), 4)), torch.tensor((float('inf'), 6)), rtol=.5)
|
|||
|
|
tensor([True, True])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def isfinite(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
isfinite(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with boolean elements representing if each element is `finite` or not.
|
|||
|
|
|
|||
|
|
Real values are finite when they are not NaN, negative infinity, or infinity.
|
|||
|
|
Complex values are finite when both their real and imaginary parts are finite.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A boolean tensor that is True where :attr:`input` is finite and False elsewhere
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.isfinite(torch.tensor([1, float('inf'), 2, float('-inf'), float('nan')]))
|
|||
|
|
tensor([True, False, True, False, False])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def isin(elements: Tensor, test_elements: Tensor, *, assume_unique: _bool = False, invert: _bool = False, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
isin(elements, test_elements, *, assume_unique=False, invert=False) -> Tensor
|
|||
|
|
|
|||
|
|
Tests if each element of :attr:`elements` is in :attr:`test_elements`. Returns
|
|||
|
|
a boolean tensor of the same shape as :attr:`elements` that is True for elements
|
|||
|
|
in :attr:`test_elements` and False otherwise.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
One of :attr:`elements` or :attr:`test_elements` can be a scalar, but not both.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
elements (Tensor or Scalar): Input elements
|
|||
|
|
test_elements (Tensor or Scalar): Values against which to test for each input element
|
|||
|
|
assume_unique (bool, optional): If True, assumes both :attr:`elements` and
|
|||
|
|
:attr:`test_elements` contain unique elements, which can speed up the
|
|||
|
|
calculation. Default: False
|
|||
|
|
invert (bool, optional): If True, inverts the boolean return tensor, resulting in True
|
|||
|
|
values for elements *not* in :attr:`test_elements`. Default: False
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A boolean tensor of the same shape as :attr:`elements` that is True for elements in
|
|||
|
|
:attr:`test_elements` and False otherwise
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
>>> torch.isin(torch.tensor([[1, 2], [3, 4]]), torch.tensor([2, 3]))
|
|||
|
|
tensor([[False, True],
|
|||
|
|
[ True, False]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def isin(element: Union[Number, _complex], test_elements: Tensor, *, assume_unique: _bool = False, invert: _bool = False, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
isin(elements, test_elements, *, assume_unique=False, invert=False) -> Tensor
|
|||
|
|
|
|||
|
|
Tests if each element of :attr:`elements` is in :attr:`test_elements`. Returns
|
|||
|
|
a boolean tensor of the same shape as :attr:`elements` that is True for elements
|
|||
|
|
in :attr:`test_elements` and False otherwise.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
One of :attr:`elements` or :attr:`test_elements` can be a scalar, but not both.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
elements (Tensor or Scalar): Input elements
|
|||
|
|
test_elements (Tensor or Scalar): Values against which to test for each input element
|
|||
|
|
assume_unique (bool, optional): If True, assumes both :attr:`elements` and
|
|||
|
|
:attr:`test_elements` contain unique elements, which can speed up the
|
|||
|
|
calculation. Default: False
|
|||
|
|
invert (bool, optional): If True, inverts the boolean return tensor, resulting in True
|
|||
|
|
values for elements *not* in :attr:`test_elements`. Default: False
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A boolean tensor of the same shape as :attr:`elements` that is True for elements in
|
|||
|
|
:attr:`test_elements` and False otherwise
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
>>> torch.isin(torch.tensor([[1, 2], [3, 4]]), torch.tensor([2, 3]))
|
|||
|
|
tensor([[False, True],
|
|||
|
|
[ True, False]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def isin(elements: Tensor, test_element: Union[Number, _complex], *, assume_unique: _bool = False, invert: _bool = False, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
isin(elements, test_elements, *, assume_unique=False, invert=False) -> Tensor
|
|||
|
|
|
|||
|
|
Tests if each element of :attr:`elements` is in :attr:`test_elements`. Returns
|
|||
|
|
a boolean tensor of the same shape as :attr:`elements` that is True for elements
|
|||
|
|
in :attr:`test_elements` and False otherwise.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
One of :attr:`elements` or :attr:`test_elements` can be a scalar, but not both.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
elements (Tensor or Scalar): Input elements
|
|||
|
|
test_elements (Tensor or Scalar): Values against which to test for each input element
|
|||
|
|
assume_unique (bool, optional): If True, assumes both :attr:`elements` and
|
|||
|
|
:attr:`test_elements` contain unique elements, which can speed up the
|
|||
|
|
calculation. Default: False
|
|||
|
|
invert (bool, optional): If True, inverts the boolean return tensor, resulting in True
|
|||
|
|
values for elements *not* in :attr:`test_elements`. Default: False
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A boolean tensor of the same shape as :attr:`elements` that is True for elements in
|
|||
|
|
:attr:`test_elements` and False otherwise
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
>>> torch.isin(torch.tensor([[1, 2], [3, 4]]), torch.tensor([2, 3]))
|
|||
|
|
tensor([[False, True],
|
|||
|
|
[ True, False]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def isinf(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
isinf(input) -> Tensor
|
|||
|
|
|
|||
|
|
Tests if each element of :attr:`input` is infinite
|
|||
|
|
(positive or negative infinity) or not.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
Complex values are infinite when their real or imaginary part is
|
|||
|
|
infinite.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A boolean tensor that is True where :attr:`input` is infinite and False elsewhere
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.isinf(torch.tensor([1, float('inf'), 2, float('-inf'), float('nan')]))
|
|||
|
|
tensor([False, True, False, True, False])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def isnan(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
isnan(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with boolean elements representing if each element of :attr:`input`
|
|||
|
|
is NaN or not. Complex values are considered NaN when either their real
|
|||
|
|
and/or imaginary part is NaN.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A boolean tensor that is True where :attr:`input` is NaN and False elsewhere
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.isnan(torch.tensor([1, float('nan'), 2]))
|
|||
|
|
tensor([False, True, False])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def isneginf(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
isneginf(input, *, out=None) -> Tensor
|
|||
|
|
Tests if each element of :attr:`input` is negative infinity or not.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([-float('inf'), float('inf'), 1.2])
|
|||
|
|
>>> torch.isneginf(a)
|
|||
|
|
tensor([ True, False, False])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def isposinf(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
isposinf(input, *, out=None) -> Tensor
|
|||
|
|
Tests if each element of :attr:`input` is positive infinity or not.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([-float('inf'), float('inf'), 1.2])
|
|||
|
|
>>> torch.isposinf(a)
|
|||
|
|
tensor([False, True, False])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def isreal(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
isreal(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with boolean elements representing if each element of :attr:`input` is real-valued or not.
|
|||
|
|
All real-valued types are considered real. Complex values are considered real when their imaginary part is 0.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A boolean tensor that is True where :attr:`input` is real and False elsewhere
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.isreal(torch.tensor([1, 1+1j, 2+0j]))
|
|||
|
|
tensor([True, False, True])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def istft(input: Tensor, n_fft: _int, hop_length: Optional[_int] = None, win_length: Optional[_int] = None, window: Optional[Tensor] = None, center: _bool = True, normalized: _bool = False, onesided: Optional[_bool] = None, length: Optional[_int] = None, return_complex: _bool = False) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def kaiser_window(window_length: _int, *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
kaiser_window(window_length, periodic=True, beta=12.0, *, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the Kaiser window with window length :attr:`window_length` and shape parameter :attr:`beta`.
|
|||
|
|
|
|||
|
|
Let I_0 be the zeroth order modified Bessel function of the first kind (see :func:`torch.i0`) and
|
|||
|
|
``N = L - 1`` if :attr:`periodic` is False and ``L`` if :attr:`periodic` is True,
|
|||
|
|
where ``L`` is the :attr:`window_length`. This function computes:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
out_i = I_0 \left( \beta \sqrt{1 - \left( {\frac{i - N/2}{N/2}} \right) ^2 } \right) / I_0( \beta )
|
|||
|
|
|
|||
|
|
Calling ``torch.kaiser_window(L, B, periodic=True)`` is equivalent to calling
|
|||
|
|
``torch.kaiser_window(L + 1, B, periodic=False)[:-1])``.
|
|||
|
|
The :attr:`periodic` argument is intended as a helpful shorthand
|
|||
|
|
to produce a periodic window as input to functions like :func:`torch.stft`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If :attr:`window_length` is one, then the returned window is a single element tensor containing a one.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
window_length (int): length of the window.
|
|||
|
|
periodic (bool, optional): If True, returns a periodic window suitable for use in spectral analysis.
|
|||
|
|
If False, returns a symmetric window suitable for use in filter design.
|
|||
|
|
beta (float, optional): shape parameter for the window.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned window tensor. Only
|
|||
|
|
``torch.strided`` (dense layout) is supported.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def kaiser_window(window_length: _int, periodic: _bool, *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
kaiser_window(window_length, periodic=True, beta=12.0, *, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the Kaiser window with window length :attr:`window_length` and shape parameter :attr:`beta`.
|
|||
|
|
|
|||
|
|
Let I_0 be the zeroth order modified Bessel function of the first kind (see :func:`torch.i0`) and
|
|||
|
|
``N = L - 1`` if :attr:`periodic` is False and ``L`` if :attr:`periodic` is True,
|
|||
|
|
where ``L`` is the :attr:`window_length`. This function computes:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
out_i = I_0 \left( \beta \sqrt{1 - \left( {\frac{i - N/2}{N/2}} \right) ^2 } \right) / I_0( \beta )
|
|||
|
|
|
|||
|
|
Calling ``torch.kaiser_window(L, B, periodic=True)`` is equivalent to calling
|
|||
|
|
``torch.kaiser_window(L + 1, B, periodic=False)[:-1])``.
|
|||
|
|
The :attr:`periodic` argument is intended as a helpful shorthand
|
|||
|
|
to produce a periodic window as input to functions like :func:`torch.stft`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If :attr:`window_length` is one, then the returned window is a single element tensor containing a one.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
window_length (int): length of the window.
|
|||
|
|
periodic (bool, optional): If True, returns a periodic window suitable for use in spectral analysis.
|
|||
|
|
If False, returns a symmetric window suitable for use in filter design.
|
|||
|
|
beta (float, optional): shape parameter for the window.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned window tensor. Only
|
|||
|
|
``torch.strided`` (dense layout) is supported.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def kaiser_window(window_length: _int, periodic: _bool, beta: _float, *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
kaiser_window(window_length, periodic=True, beta=12.0, *, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the Kaiser window with window length :attr:`window_length` and shape parameter :attr:`beta`.
|
|||
|
|
|
|||
|
|
Let I_0 be the zeroth order modified Bessel function of the first kind (see :func:`torch.i0`) and
|
|||
|
|
``N = L - 1`` if :attr:`periodic` is False and ``L`` if :attr:`periodic` is True,
|
|||
|
|
where ``L`` is the :attr:`window_length`. This function computes:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
out_i = I_0 \left( \beta \sqrt{1 - \left( {\frac{i - N/2}{N/2}} \right) ^2 } \right) / I_0( \beta )
|
|||
|
|
|
|||
|
|
Calling ``torch.kaiser_window(L, B, periodic=True)`` is equivalent to calling
|
|||
|
|
``torch.kaiser_window(L + 1, B, periodic=False)[:-1])``.
|
|||
|
|
The :attr:`periodic` argument is intended as a helpful shorthand
|
|||
|
|
to produce a periodic window as input to functions like :func:`torch.stft`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If :attr:`window_length` is one, then the returned window is a single element tensor containing a one.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
window_length (int): length of the window.
|
|||
|
|
periodic (bool, optional): If True, returns a periodic window suitable for use in spectral analysis.
|
|||
|
|
If False, returns a symmetric window suitable for use in filter design.
|
|||
|
|
beta (float, optional): shape parameter for the window.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned window tensor. Only
|
|||
|
|
``torch.strided`` (dense layout) is supported.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def kl_div(input: Tensor, target: Tensor, reduction: _int = 1, *, log_target: _bool = False) -> Tensor: ...
|
|||
|
|
def kron(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
kron(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the Kronecker product, denoted by :math:`\otimes`, of :attr:`input` and :attr:`other`.
|
|||
|
|
|
|||
|
|
If :attr:`input` is a :math:`(a_0 \times a_1 \times \dots \times a_n)` tensor and :attr:`other` is a
|
|||
|
|
:math:`(b_0 \times b_1 \times \dots \times b_n)` tensor, the result will be a
|
|||
|
|
:math:`(a_0*b_0 \times a_1*b_1 \times \dots \times a_n*b_n)` tensor with the following entries:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
(\text{input} \otimes \text{other})_{k_0, k_1, \dots, k_n} =
|
|||
|
|
\text{input}_{i_0, i_1, \dots, i_n} * \text{other}_{j_0, j_1, \dots, j_n},
|
|||
|
|
|
|||
|
|
where :math:`k_t = i_t * b_t + j_t` for :math:`0 \leq t \leq n`.
|
|||
|
|
If one tensor has fewer dimensions than the other it is unsqueezed until it has the same number of dimensions.
|
|||
|
|
|
|||
|
|
Supports real-valued and complex-valued inputs.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
This function generalizes the typical definition of the Kronecker product for two matrices to two tensors,
|
|||
|
|
as described above. When :attr:`input` is a :math:`(m \times n)` matrix and :attr:`other` is a
|
|||
|
|
:math:`(p \times q)` matrix, the result will be a :math:`(p*m \times q*n)` block matrix:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\mathbf{A} \otimes \mathbf{B}=\begin{bmatrix}
|
|||
|
|
a_{11} \mathbf{B} & \cdots & a_{1 n} \mathbf{B} \\
|
|||
|
|
\vdots & \ddots & \vdots \\
|
|||
|
|
a_{m 1} \mathbf{B} & \cdots & a_{m n} \mathbf{B} \end{bmatrix}
|
|||
|
|
|
|||
|
|
where :attr:`input` is :math:`\mathbf{A}` and :attr:`other` is :math:`\mathbf{B}`.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
input (Tensor)
|
|||
|
|
other (Tensor)
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): The output tensor. Ignored if ``None``. Default: ``None``
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> mat1 = torch.eye(2)
|
|||
|
|
>>> mat2 = torch.ones(2, 2)
|
|||
|
|
>>> torch.kron(mat1, mat2)
|
|||
|
|
tensor([[1., 1., 0., 0.],
|
|||
|
|
[1., 1., 0., 0.],
|
|||
|
|
[0., 0., 1., 1.],
|
|||
|
|
[0., 0., 1., 1.]])
|
|||
|
|
|
|||
|
|
>>> mat1 = torch.eye(2)
|
|||
|
|
>>> mat2 = torch.arange(1, 5).reshape(2, 2)
|
|||
|
|
>>> torch.kron(mat1, mat2)
|
|||
|
|
tensor([[1., 2., 0., 0.],
|
|||
|
|
[3., 4., 0., 0.],
|
|||
|
|
[0., 0., 1., 2.],
|
|||
|
|
[0., 0., 3., 4.]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def kthvalue(input: Tensor, k: _int, dim: _int = -1, keepdim: _bool = False, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.kthvalue:
|
|||
|
|
r"""
|
|||
|
|
kthvalue(input, k, dim=None, keepdim=False, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
|
|||
|
|
Returns a namedtuple ``(values, indices)`` where ``values`` is the :attr:`k` th
|
|||
|
|
smallest element of each row of the :attr:`input` tensor in the given dimension
|
|||
|
|
:attr:`dim`. And ``indices`` is the index location of each element found.
|
|||
|
|
|
|||
|
|
If :attr:`dim` is not given, the last dimension of the `input` is chosen.
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, both the :attr:`values` and :attr:`indices` tensors
|
|||
|
|
are the same size as :attr:`input`, except in the dimension :attr:`dim` where
|
|||
|
|
they are of size 1. Otherwise, :attr:`dim` is squeezed
|
|||
|
|
(see :func:`torch.squeeze`), resulting in both the :attr:`values` and
|
|||
|
|
:attr:`indices` tensors having 1 fewer dimension than the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
When :attr:`input` is a CUDA tensor and there are multiple valid
|
|||
|
|
:attr:`k` th values, this function may nondeterministically return
|
|||
|
|
:attr:`indices` for any of them.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
k (int): k for the k-th smallest element
|
|||
|
|
dim (int, optional): the dimension to find the kth value along
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the output tuple of (Tensor, LongTensor)
|
|||
|
|
can be optionally given to be used as output buffers
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.arange(1., 6.)
|
|||
|
|
>>> x
|
|||
|
|
tensor([ 1., 2., 3., 4., 5.])
|
|||
|
|
>>> torch.kthvalue(x, 4)
|
|||
|
|
torch.return_types.kthvalue(values=tensor(4.), indices=tensor(3))
|
|||
|
|
|
|||
|
|
>>> x=torch.arange(1.,7.).resize_(2,3)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 1., 2., 3.],
|
|||
|
|
[ 4., 5., 6.]])
|
|||
|
|
>>> torch.kthvalue(x, 2, 0, True)
|
|||
|
|
torch.return_types.kthvalue(values=tensor([[4., 5., 6.]]), indices=tensor([[1, 1, 1]]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def kthvalue(input: Tensor, k: _int, dim: Union[str, ellipsis, None], keepdim: _bool = False, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.kthvalue:
|
|||
|
|
r"""
|
|||
|
|
kthvalue(input, k, dim=None, keepdim=False, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
|
|||
|
|
Returns a namedtuple ``(values, indices)`` where ``values`` is the :attr:`k` th
|
|||
|
|
smallest element of each row of the :attr:`input` tensor in the given dimension
|
|||
|
|
:attr:`dim`. And ``indices`` is the index location of each element found.
|
|||
|
|
|
|||
|
|
If :attr:`dim` is not given, the last dimension of the `input` is chosen.
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, both the :attr:`values` and :attr:`indices` tensors
|
|||
|
|
are the same size as :attr:`input`, except in the dimension :attr:`dim` where
|
|||
|
|
they are of size 1. Otherwise, :attr:`dim` is squeezed
|
|||
|
|
(see :func:`torch.squeeze`), resulting in both the :attr:`values` and
|
|||
|
|
:attr:`indices` tensors having 1 fewer dimension than the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
When :attr:`input` is a CUDA tensor and there are multiple valid
|
|||
|
|
:attr:`k` th values, this function may nondeterministically return
|
|||
|
|
:attr:`indices` for any of them.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
k (int): k for the k-th smallest element
|
|||
|
|
dim (int, optional): the dimension to find the kth value along
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the output tuple of (Tensor, LongTensor)
|
|||
|
|
can be optionally given to be used as output buffers
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.arange(1., 6.)
|
|||
|
|
>>> x
|
|||
|
|
tensor([ 1., 2., 3., 4., 5.])
|
|||
|
|
>>> torch.kthvalue(x, 4)
|
|||
|
|
torch.return_types.kthvalue(values=tensor(4.), indices=tensor(3))
|
|||
|
|
|
|||
|
|
>>> x=torch.arange(1.,7.).resize_(2,3)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 1., 2., 3.],
|
|||
|
|
[ 4., 5., 6.]])
|
|||
|
|
>>> torch.kthvalue(x, 2, 0, True)
|
|||
|
|
torch.return_types.kthvalue(values=tensor([[4., 5., 6.]]), indices=tensor([[1, 1, 1]]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def layer_norm(input: Tensor, normalized_shape: Sequence[Union[_int, SymInt]], weight: Optional[Tensor] = None, bias: Optional[Tensor] = None, eps: _float = 1e-05, cudnn_enable: _bool = True) -> Tensor: ...
|
|||
|
|
def lcm(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
lcm(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the element-wise least common multiple (LCM) of :attr:`input` and :attr:`other`.
|
|||
|
|
|
|||
|
|
Both :attr:`input` and :attr:`other` must have integer types.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
This defines :math:`lcm(0, 0) = 0` and :math:`lcm(0, a) = 0`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
other (Tensor): the second input tensor
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([5, 10, 15])
|
|||
|
|
>>> b = torch.tensor([3, 4, 5])
|
|||
|
|
>>> torch.lcm(a, b)
|
|||
|
|
tensor([15, 20, 15])
|
|||
|
|
>>> c = torch.tensor([3])
|
|||
|
|
>>> torch.lcm(a, c)
|
|||
|
|
tensor([15, 30, 15])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def lcm_(input: Tensor, other: Tensor) -> Tensor: ...
|
|||
|
|
def ldexp(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
ldexp(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Multiplies :attr:`input` by 2 ** :attr:`other`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{{out}}_i = \text{{input}}_i * 2^\text{{other}}_i
|
|||
|
|
|
|||
|
|
|
|||
|
|
Typically this function is used to construct floating point numbers by multiplying
|
|||
|
|
mantissas in :attr:`input` with integral powers of two created from the exponents
|
|||
|
|
in :attr:`other`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
other (Tensor): a tensor of exponents, typically integers.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.ldexp(torch.tensor([1.]), torch.tensor([1]))
|
|||
|
|
tensor([2.])
|
|||
|
|
>>> torch.ldexp(torch.tensor([1.0]), torch.tensor([1, 2, 3, 4]))
|
|||
|
|
tensor([ 2., 4., 8., 16.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def ldexp_(input: Tensor, other: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def le(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
le(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes :math:`\text{input} \leq \text{other}` element-wise.
|
|||
|
|
|
|||
|
|
|
|||
|
|
The second argument can be a number or a tensor whose shape is
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with the first argument.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to compare
|
|||
|
|
other (Tensor or Scalar): the tensor or value to compare
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A boolean tensor that is True where :attr:`input` is less than or equal to
|
|||
|
|
:attr:`other` and False elsewhere
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.le(torch.tensor([[1, 2], [3, 4]]), torch.tensor([[1, 1], [4, 4]]))
|
|||
|
|
tensor([[True, False], [True, True]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def le(input: Tensor, other: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
le(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes :math:`\text{input} \leq \text{other}` element-wise.
|
|||
|
|
|
|||
|
|
|
|||
|
|
The second argument can be a number or a tensor whose shape is
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with the first argument.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to compare
|
|||
|
|
other (Tensor or Scalar): the tensor or value to compare
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A boolean tensor that is True where :attr:`input` is less than or equal to
|
|||
|
|
:attr:`other` and False elsewhere
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.le(torch.tensor([[1, 2], [3, 4]]), torch.tensor([[1, 1], [4, 4]]))
|
|||
|
|
tensor([[True, False], [True, True]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def lerp(input: Tensor, end: Tensor, weight: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
lerp(input, end, weight, *, out=None)
|
|||
|
|
|
|||
|
|
Does a linear interpolation of two tensors :attr:`start` (given by :attr:`input`) and :attr:`end` based
|
|||
|
|
on a scalar or tensor :attr:`weight` and returns the resulting :attr:`out` tensor.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \text{start}_i + \text{weight}_i \times (\text{end}_i - \text{start}_i)
|
|||
|
|
|
|||
|
|
The shapes of :attr:`start` and :attr:`end` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>`. If :attr:`weight` is a tensor, then
|
|||
|
|
the shapes of :attr:`weight`, :attr:`start`, and :attr:`end` must be :ref:`broadcastable <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor with the starting points
|
|||
|
|
end (Tensor): the tensor with the ending points
|
|||
|
|
weight (float or tensor): the weight for the interpolation formula
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> start = torch.arange(1., 5.)
|
|||
|
|
>>> end = torch.empty(4).fill_(10)
|
|||
|
|
>>> start
|
|||
|
|
tensor([ 1., 2., 3., 4.])
|
|||
|
|
>>> end
|
|||
|
|
tensor([ 10., 10., 10., 10.])
|
|||
|
|
>>> torch.lerp(start, end, 0.5)
|
|||
|
|
tensor([ 5.5000, 6.0000, 6.5000, 7.0000])
|
|||
|
|
>>> torch.lerp(start, end, torch.full_like(start, 0.5))
|
|||
|
|
tensor([ 5.5000, 6.0000, 6.5000, 7.0000])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def lerp(input: Tensor, end: Tensor, weight: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
lerp(input, end, weight, *, out=None)
|
|||
|
|
|
|||
|
|
Does a linear interpolation of two tensors :attr:`start` (given by :attr:`input`) and :attr:`end` based
|
|||
|
|
on a scalar or tensor :attr:`weight` and returns the resulting :attr:`out` tensor.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \text{start}_i + \text{weight}_i \times (\text{end}_i - \text{start}_i)
|
|||
|
|
|
|||
|
|
The shapes of :attr:`start` and :attr:`end` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>`. If :attr:`weight` is a tensor, then
|
|||
|
|
the shapes of :attr:`weight`, :attr:`start`, and :attr:`end` must be :ref:`broadcastable <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor with the starting points
|
|||
|
|
end (Tensor): the tensor with the ending points
|
|||
|
|
weight (float or tensor): the weight for the interpolation formula
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> start = torch.arange(1., 5.)
|
|||
|
|
>>> end = torch.empty(4).fill_(10)
|
|||
|
|
>>> start
|
|||
|
|
tensor([ 1., 2., 3., 4.])
|
|||
|
|
>>> end
|
|||
|
|
tensor([ 10., 10., 10., 10.])
|
|||
|
|
>>> torch.lerp(start, end, 0.5)
|
|||
|
|
tensor([ 5.5000, 6.0000, 6.5000, 7.0000])
|
|||
|
|
>>> torch.lerp(start, end, torch.full_like(start, 0.5))
|
|||
|
|
tensor([ 5.5000, 6.0000, 6.5000, 7.0000])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def less(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
less(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.lt`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def less(input: Tensor, other: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
less(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.lt`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def less_equal(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
less_equal(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.le`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def less_equal(input: Tensor, other: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
less_equal(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.le`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def lgamma(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
lgamma(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the natural logarithm of the absolute value of the gamma function on :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \ln |\Gamma(\text{input}_{i})|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.arange(0.5, 2, 0.5)
|
|||
|
|
>>> torch.lgamma(a)
|
|||
|
|
tensor([ 0.5724, 0.0000, -0.1208])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def linspace(start: Number, end: Number, steps: Optional[_int] = None, *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, device: Optional[DeviceLikeType] = None, requires_grad: _bool = False, pin_memory: _bool = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
linspace(start, end, steps, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Creates a one-dimensional tensor of size :attr:`steps` whose values are evenly
|
|||
|
|
spaced from :attr:`start` to :attr:`end`, inclusive. That is, the value are:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
(\text{start},
|
|||
|
|
\text{start} + \frac{\text{end} - \text{start}}{\text{steps} - 1},
|
|||
|
|
\ldots,
|
|||
|
|
\text{start} + (\text{steps} - 2) * \frac{\text{end} - \text{start}}{\text{steps} - 1},
|
|||
|
|
\text{end})
|
|||
|
|
|
|||
|
|
|
|||
|
|
From PyTorch 1.11 linspace requires the steps argument. Use steps=100 to restore the previous behavior.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
start (float or Tensor): the starting value for the set of points. If `Tensor`, it must be 0-dimensional
|
|||
|
|
end (float or Tensor): the ending value for the set of points. If `Tensor`, it must be 0-dimensional
|
|||
|
|
steps (int): size of the constructed tensor
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (torch.dtype, optional): the data type to perform the computation in.
|
|||
|
|
Default: if None, uses the global default dtype (see torch.get_default_dtype())
|
|||
|
|
when both :attr:`start` and :attr:`end` are real,
|
|||
|
|
and corresponding complex dtype when either is complex.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.linspace(3, 10, steps=5)
|
|||
|
|
tensor([ 3.0000, 4.7500, 6.5000, 8.2500, 10.0000])
|
|||
|
|
>>> torch.linspace(-10, 10, steps=5)
|
|||
|
|
tensor([-10., -5., 0., 5., 10.])
|
|||
|
|
>>> torch.linspace(start=-10, end=10, steps=5)
|
|||
|
|
tensor([-10., -5., 0., 5., 10.])
|
|||
|
|
>>> torch.linspace(start=-10, end=10, steps=1)
|
|||
|
|
tensor([-10.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def linspace(start: Tensor, end: Tensor, steps: _int, *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
linspace(start, end, steps, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Creates a one-dimensional tensor of size :attr:`steps` whose values are evenly
|
|||
|
|
spaced from :attr:`start` to :attr:`end`, inclusive. That is, the value are:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
(\text{start},
|
|||
|
|
\text{start} + \frac{\text{end} - \text{start}}{\text{steps} - 1},
|
|||
|
|
\ldots,
|
|||
|
|
\text{start} + (\text{steps} - 2) * \frac{\text{end} - \text{start}}{\text{steps} - 1},
|
|||
|
|
\text{end})
|
|||
|
|
|
|||
|
|
|
|||
|
|
From PyTorch 1.11 linspace requires the steps argument. Use steps=100 to restore the previous behavior.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
start (float or Tensor): the starting value for the set of points. If `Tensor`, it must be 0-dimensional
|
|||
|
|
end (float or Tensor): the ending value for the set of points. If `Tensor`, it must be 0-dimensional
|
|||
|
|
steps (int): size of the constructed tensor
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (torch.dtype, optional): the data type to perform the computation in.
|
|||
|
|
Default: if None, uses the global default dtype (see torch.get_default_dtype())
|
|||
|
|
when both :attr:`start` and :attr:`end` are real,
|
|||
|
|
and corresponding complex dtype when either is complex.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.linspace(3, 10, steps=5)
|
|||
|
|
tensor([ 3.0000, 4.7500, 6.5000, 8.2500, 10.0000])
|
|||
|
|
>>> torch.linspace(-10, 10, steps=5)
|
|||
|
|
tensor([-10., -5., 0., 5., 10.])
|
|||
|
|
>>> torch.linspace(start=-10, end=10, steps=5)
|
|||
|
|
tensor([-10., -5., 0., 5., 10.])
|
|||
|
|
>>> torch.linspace(start=-10, end=10, steps=1)
|
|||
|
|
tensor([-10.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def linspace(start: Union[Number, _complex], end: Tensor, steps: _int, *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
linspace(start, end, steps, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Creates a one-dimensional tensor of size :attr:`steps` whose values are evenly
|
|||
|
|
spaced from :attr:`start` to :attr:`end`, inclusive. That is, the value are:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
(\text{start},
|
|||
|
|
\text{start} + \frac{\text{end} - \text{start}}{\text{steps} - 1},
|
|||
|
|
\ldots,
|
|||
|
|
\text{start} + (\text{steps} - 2) * \frac{\text{end} - \text{start}}{\text{steps} - 1},
|
|||
|
|
\text{end})
|
|||
|
|
|
|||
|
|
|
|||
|
|
From PyTorch 1.11 linspace requires the steps argument. Use steps=100 to restore the previous behavior.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
start (float or Tensor): the starting value for the set of points. If `Tensor`, it must be 0-dimensional
|
|||
|
|
end (float or Tensor): the ending value for the set of points. If `Tensor`, it must be 0-dimensional
|
|||
|
|
steps (int): size of the constructed tensor
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (torch.dtype, optional): the data type to perform the computation in.
|
|||
|
|
Default: if None, uses the global default dtype (see torch.get_default_dtype())
|
|||
|
|
when both :attr:`start` and :attr:`end` are real,
|
|||
|
|
and corresponding complex dtype when either is complex.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.linspace(3, 10, steps=5)
|
|||
|
|
tensor([ 3.0000, 4.7500, 6.5000, 8.2500, 10.0000])
|
|||
|
|
>>> torch.linspace(-10, 10, steps=5)
|
|||
|
|
tensor([-10., -5., 0., 5., 10.])
|
|||
|
|
>>> torch.linspace(start=-10, end=10, steps=5)
|
|||
|
|
tensor([-10., -5., 0., 5., 10.])
|
|||
|
|
>>> torch.linspace(start=-10, end=10, steps=1)
|
|||
|
|
tensor([-10.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def linspace(start: Tensor, end: Union[Number, _complex], steps: _int, *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
linspace(start, end, steps, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Creates a one-dimensional tensor of size :attr:`steps` whose values are evenly
|
|||
|
|
spaced from :attr:`start` to :attr:`end`, inclusive. That is, the value are:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
(\text{start},
|
|||
|
|
\text{start} + \frac{\text{end} - \text{start}}{\text{steps} - 1},
|
|||
|
|
\ldots,
|
|||
|
|
\text{start} + (\text{steps} - 2) * \frac{\text{end} - \text{start}}{\text{steps} - 1},
|
|||
|
|
\text{end})
|
|||
|
|
|
|||
|
|
|
|||
|
|
From PyTorch 1.11 linspace requires the steps argument. Use steps=100 to restore the previous behavior.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
start (float or Tensor): the starting value for the set of points. If `Tensor`, it must be 0-dimensional
|
|||
|
|
end (float or Tensor): the ending value for the set of points. If `Tensor`, it must be 0-dimensional
|
|||
|
|
steps (int): size of the constructed tensor
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (torch.dtype, optional): the data type to perform the computation in.
|
|||
|
|
Default: if None, uses the global default dtype (see torch.get_default_dtype())
|
|||
|
|
when both :attr:`start` and :attr:`end` are real,
|
|||
|
|
and corresponding complex dtype when either is complex.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.linspace(3, 10, steps=5)
|
|||
|
|
tensor([ 3.0000, 4.7500, 6.5000, 8.2500, 10.0000])
|
|||
|
|
>>> torch.linspace(-10, 10, steps=5)
|
|||
|
|
tensor([-10., -5., 0., 5., 10.])
|
|||
|
|
>>> torch.linspace(start=-10, end=10, steps=5)
|
|||
|
|
tensor([-10., -5., 0., 5., 10.])
|
|||
|
|
>>> torch.linspace(start=-10, end=10, steps=1)
|
|||
|
|
tensor([-10.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def linspace(start: Union[Number, _complex], end: Union[Number, _complex], steps: _int, *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
linspace(start, end, steps, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Creates a one-dimensional tensor of size :attr:`steps` whose values are evenly
|
|||
|
|
spaced from :attr:`start` to :attr:`end`, inclusive. That is, the value are:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
(\text{start},
|
|||
|
|
\text{start} + \frac{\text{end} - \text{start}}{\text{steps} - 1},
|
|||
|
|
\ldots,
|
|||
|
|
\text{start} + (\text{steps} - 2) * \frac{\text{end} - \text{start}}{\text{steps} - 1},
|
|||
|
|
\text{end})
|
|||
|
|
|
|||
|
|
|
|||
|
|
From PyTorch 1.11 linspace requires the steps argument. Use steps=100 to restore the previous behavior.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
start (float or Tensor): the starting value for the set of points. If `Tensor`, it must be 0-dimensional
|
|||
|
|
end (float or Tensor): the ending value for the set of points. If `Tensor`, it must be 0-dimensional
|
|||
|
|
steps (int): size of the constructed tensor
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (torch.dtype, optional): the data type to perform the computation in.
|
|||
|
|
Default: if None, uses the global default dtype (see torch.get_default_dtype())
|
|||
|
|
when both :attr:`start` and :attr:`end` are real,
|
|||
|
|
and corresponding complex dtype when either is complex.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.linspace(3, 10, steps=5)
|
|||
|
|
tensor([ 3.0000, 4.7500, 6.5000, 8.2500, 10.0000])
|
|||
|
|
>>> torch.linspace(-10, 10, steps=5)
|
|||
|
|
tensor([-10., -5., 0., 5., 10.])
|
|||
|
|
>>> torch.linspace(start=-10, end=10, steps=5)
|
|||
|
|
tensor([-10., -5., 0., 5., 10.])
|
|||
|
|
>>> torch.linspace(start=-10, end=10, steps=1)
|
|||
|
|
tensor([-10.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def log(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
log(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the natural logarithm of the elements
|
|||
|
|
of :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
y_{i} = \log_{e} (x_{i})
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.rand(5) * 5
|
|||
|
|
>>> a
|
|||
|
|
tensor([4.7767, 4.3234, 1.2156, 0.2411, 4.5739])
|
|||
|
|
>>> torch.log(a)
|
|||
|
|
tensor([ 1.5637, 1.4640, 0.1952, -1.4226, 1.5204])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def log10(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
log10(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the logarithm to the base 10 of the elements
|
|||
|
|
of :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
y_{i} = \log_{10} (x_{i})
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.rand(5)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 0.5224, 0.9354, 0.7257, 0.1301, 0.2251])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> torch.log10(a)
|
|||
|
|
tensor([-0.2820, -0.0290, -0.1392, -0.8857, -0.6476])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def log10_(input: Tensor) -> Tensor: ...
|
|||
|
|
def log1p(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
log1p(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the natural logarithm of (1 + :attr:`input`).
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
y_i = \log_{e} (x_i + 1)
|
|||
|
|
|
|||
|
|
.. note:: This function is more accurate than :func:`torch.log` for small
|
|||
|
|
values of :attr:`input`
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(5)
|
|||
|
|
>>> a
|
|||
|
|
tensor([-1.0090, -0.9923, 1.0249, -0.5372, 0.2492])
|
|||
|
|
>>> torch.log1p(a)
|
|||
|
|
tensor([ nan, -4.8653, 0.7055, -0.7705, 0.2225])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def log1p_(input: Tensor) -> Tensor: ...
|
|||
|
|
def log2(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
log2(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the logarithm to the base 2 of the elements
|
|||
|
|
of :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
y_{i} = \log_{2} (x_{i})
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.rand(5)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 0.8419, 0.8003, 0.9971, 0.5287, 0.0490])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> torch.log2(a)
|
|||
|
|
tensor([-0.2483, -0.3213, -0.0042, -0.9196, -4.3504])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def log2_(input: Tensor) -> Tensor: ...
|
|||
|
|
def log_(input: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def log_softmax(input: Tensor, dim: _int, dtype: Optional[_dtype] = None, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def log_softmax(input: Tensor, dim: Union[str, ellipsis, None], *, dtype: Optional[_dtype] = None) -> Tensor: ...
|
|||
|
|
def logaddexp(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
logaddexp(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Logarithm of the sum of exponentiations of the inputs.
|
|||
|
|
|
|||
|
|
Calculates pointwise :math:`\log\left(e^x + e^y\right)`. This function is useful
|
|||
|
|
in statistics where the calculated probabilities of events may be so small as to
|
|||
|
|
exceed the range of normal floating point numbers. In such cases the logarithm
|
|||
|
|
of the calculated probability is stored. This function allows adding
|
|||
|
|
probabilities stored in such a fashion.
|
|||
|
|
|
|||
|
|
This op should be disambiguated with :func:`torch.logsumexp` which performs a
|
|||
|
|
reduction on a single tensor.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
other (Tensor): the second input tensor
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.logaddexp(torch.tensor([-1.0]), torch.tensor([-1.0, -2, -3]))
|
|||
|
|
tensor([-0.3069, -0.6867, -0.8731])
|
|||
|
|
>>> torch.logaddexp(torch.tensor([-100.0, -200, -300]), torch.tensor([-1.0, -2, -3]))
|
|||
|
|
tensor([-1., -2., -3.])
|
|||
|
|
>>> torch.logaddexp(torch.tensor([1.0, 2000, 30000]), torch.tensor([-1.0, -2, -3]))
|
|||
|
|
tensor([1.1269e+00, 2.0000e+03, 3.0000e+04])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def logaddexp2(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
logaddexp2(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Logarithm of the sum of exponentiations of the inputs in base-2.
|
|||
|
|
|
|||
|
|
Calculates pointwise :math:`\log_2\left(2^x + 2^y\right)`. See
|
|||
|
|
:func:`torch.logaddexp` for more details.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
other (Tensor): the second input tensor
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def logcumsumexp(input: Tensor, dim: _int, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
logcumsumexp(input, dim, *, out=None) -> Tensor
|
|||
|
|
Returns the logarithm of the cumulative summation of the exponentiation of
|
|||
|
|
elements of :attr:`input` in the dimension :attr:`dim`.
|
|||
|
|
|
|||
|
|
For summation index :math:`j` given by `dim` and other indices :math:`i`, the result is
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{logcumsumexp}(x)_{ij} = \log \sum\limits_{j=0}^{i} \exp(x_{ij})
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to do the operation over
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(10)
|
|||
|
|
>>> torch.logcumsumexp(a, dim=0)
|
|||
|
|
tensor([-0.42296738, -0.04462666, 0.86278635, 0.94622083, 1.05277811,
|
|||
|
|
1.39202815, 1.83525007, 1.84492621, 2.06084887, 2.06844475]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def logcumsumexp(input: Tensor, dim: Union[str, ellipsis, None], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
logcumsumexp(input, dim, *, out=None) -> Tensor
|
|||
|
|
Returns the logarithm of the cumulative summation of the exponentiation of
|
|||
|
|
elements of :attr:`input` in the dimension :attr:`dim`.
|
|||
|
|
|
|||
|
|
For summation index :math:`j` given by `dim` and other indices :math:`i`, the result is
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{logcumsumexp}(x)_{ij} = \log \sum\limits_{j=0}^{i} \exp(x_{ij})
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to do the operation over
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(10)
|
|||
|
|
>>> torch.logcumsumexp(a, dim=0)
|
|||
|
|
tensor([-0.42296738, -0.04462666, 0.86278635, 0.94622083, 1.05277811,
|
|||
|
|
1.39202815, 1.83525007, 1.84492621, 2.06084887, 2.06844475]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def logdet(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
logdet(input) -> Tensor
|
|||
|
|
|
|||
|
|
Calculates log determinant of a square matrix or batches of square matrices.
|
|||
|
|
|
|||
|
|
It returns ``-inf`` if the input has a determinant of zero, and ``NaN`` if it has
|
|||
|
|
a negative determinant.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
Backward through :meth:`logdet` internally uses SVD results when :attr:`input`
|
|||
|
|
is not invertible. In this case, double backward through :meth:`logdet` will
|
|||
|
|
be unstable in when :attr:`input` doesn't have distinct singular values. See
|
|||
|
|
:func:`torch.linalg.svd` for details.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.linalg.slogdet` computes the sign (resp. angle) and natural logarithm of the
|
|||
|
|
absolute value of the determinant of real-valued (resp. complex) square matrices.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
input (Tensor): the input tensor of size ``(*, n, n)`` where ``*`` is zero or more
|
|||
|
|
batch dimensions.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> A = torch.randn(3, 3)
|
|||
|
|
>>> torch.det(A)
|
|||
|
|
tensor(0.2611)
|
|||
|
|
>>> torch.logdet(A)
|
|||
|
|
tensor(-1.3430)
|
|||
|
|
>>> A
|
|||
|
|
tensor([[[ 0.9254, -0.6213],
|
|||
|
|
[-0.5787, 1.6843]],
|
|||
|
|
|
|||
|
|
[[ 0.3242, -0.9665],
|
|||
|
|
[ 0.4539, -0.0887]],
|
|||
|
|
|
|||
|
|
[[ 1.1336, -0.4025],
|
|||
|
|
[-0.7089, 0.9032]]])
|
|||
|
|
>>> A.det()
|
|||
|
|
tensor([1.1990, 0.4099, 0.7386])
|
|||
|
|
>>> A.det().log()
|
|||
|
|
tensor([ 0.1815, -0.8917, -0.3031])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def logical_and(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
logical_and(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the element-wise logical AND of the given input tensors. Zeros are treated as ``False`` and nonzeros are
|
|||
|
|
treated as ``True``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
other (Tensor): the tensor to compute AND with
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.logical_and(torch.tensor([True, False, True]), torch.tensor([True, False, False]))
|
|||
|
|
tensor([ True, False, False])
|
|||
|
|
>>> a = torch.tensor([0, 1, 10, 0], dtype=torch.int8)
|
|||
|
|
>>> b = torch.tensor([4, 0, 1, 0], dtype=torch.int8)
|
|||
|
|
>>> torch.logical_and(a, b)
|
|||
|
|
tensor([False, False, True, False])
|
|||
|
|
>>> torch.logical_and(a.double(), b.double())
|
|||
|
|
tensor([False, False, True, False])
|
|||
|
|
>>> torch.logical_and(a.double(), b)
|
|||
|
|
tensor([False, False, True, False])
|
|||
|
|
>>> torch.logical_and(a, b, out=torch.empty(4, dtype=torch.bool))
|
|||
|
|
tensor([False, False, True, False])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def logical_not(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
logical_not(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the element-wise logical NOT of the given input tensor. If not specified, the output tensor will have the bool
|
|||
|
|
dtype. If the input tensor is not a bool tensor, zeros are treated as ``False`` and non-zeros are treated as ``True``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.logical_not(torch.tensor([True, False]))
|
|||
|
|
tensor([False, True])
|
|||
|
|
>>> torch.logical_not(torch.tensor([0, 1, -10], dtype=torch.int8))
|
|||
|
|
tensor([ True, False, False])
|
|||
|
|
>>> torch.logical_not(torch.tensor([0., 1.5, -10.], dtype=torch.double))
|
|||
|
|
tensor([ True, False, False])
|
|||
|
|
>>> torch.logical_not(torch.tensor([0., 1., -10.], dtype=torch.double), out=torch.empty(3, dtype=torch.int16))
|
|||
|
|
tensor([1, 0, 0], dtype=torch.int16)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def logical_or(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
logical_or(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the element-wise logical OR of the given input tensors. Zeros are treated as ``False`` and nonzeros are
|
|||
|
|
treated as ``True``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
other (Tensor): the tensor to compute OR with
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.logical_or(torch.tensor([True, False, True]), torch.tensor([True, False, False]))
|
|||
|
|
tensor([ True, False, True])
|
|||
|
|
>>> a = torch.tensor([0, 1, 10, 0], dtype=torch.int8)
|
|||
|
|
>>> b = torch.tensor([4, 0, 1, 0], dtype=torch.int8)
|
|||
|
|
>>> torch.logical_or(a, b)
|
|||
|
|
tensor([ True, True, True, False])
|
|||
|
|
>>> torch.logical_or(a.double(), b.double())
|
|||
|
|
tensor([ True, True, True, False])
|
|||
|
|
>>> torch.logical_or(a.double(), b)
|
|||
|
|
tensor([ True, True, True, False])
|
|||
|
|
>>> torch.logical_or(a, b, out=torch.empty(4, dtype=torch.bool))
|
|||
|
|
tensor([ True, True, True, False])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def logical_xor(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
logical_xor(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the element-wise logical XOR of the given input tensors. Zeros are treated as ``False`` and nonzeros are
|
|||
|
|
treated as ``True``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
other (Tensor): the tensor to compute XOR with
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.logical_xor(torch.tensor([True, False, True]), torch.tensor([True, False, False]))
|
|||
|
|
tensor([False, False, True])
|
|||
|
|
>>> a = torch.tensor([0, 1, 10, 0], dtype=torch.int8)
|
|||
|
|
>>> b = torch.tensor([4, 0, 1, 0], dtype=torch.int8)
|
|||
|
|
>>> torch.logical_xor(a, b)
|
|||
|
|
tensor([ True, True, False, False])
|
|||
|
|
>>> torch.logical_xor(a.double(), b.double())
|
|||
|
|
tensor([ True, True, False, False])
|
|||
|
|
>>> torch.logical_xor(a.double(), b)
|
|||
|
|
tensor([ True, True, False, False])
|
|||
|
|
>>> torch.logical_xor(a, b, out=torch.empty(4, dtype=torch.bool))
|
|||
|
|
tensor([ True, True, False, False])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def logit(input: Tensor, eps: Optional[_float] = None, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
logit(input, eps=None, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.special.logit`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def logit_(input: Tensor, eps: Optional[_float] = None) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def logspace(start: Number, end: Number, steps: Optional[_int] = None, base: _float = 10.0, *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, device: Optional[DeviceLikeType] = None, requires_grad: _bool = False, pin_memory: _bool = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
logspace(start, end, steps, base=10.0, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
|
|||
|
|
Creates a one-dimensional tensor of size :attr:`steps` whose values are evenly
|
|||
|
|
spaced from :math:`{{\text{{base}}}}^{{\text{{start}}}}` to
|
|||
|
|
:math:`{{\text{{base}}}}^{{\text{{end}}}}`, inclusive, on a logarithmic scale
|
|||
|
|
with base :attr:`base`. That is, the values are:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
(\text{base}^{\text{start}},
|
|||
|
|
\text{base}^{(\text{start} + \frac{\text{end} - \text{start}}{ \text{steps} - 1})},
|
|||
|
|
\ldots,
|
|||
|
|
\text{base}^{(\text{start} + (\text{steps} - 2) * \frac{\text{end} - \text{start}}{ \text{steps} - 1})},
|
|||
|
|
\text{base}^{\text{end}})
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
From PyTorch 1.11 logspace requires the steps argument. Use steps=100 to restore the previous behavior.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
start (float or Tensor): the starting value for the set of points. If `Tensor`, it must be 0-dimensional
|
|||
|
|
end (float or Tensor): the ending value for the set of points. If `Tensor`, it must be 0-dimensional
|
|||
|
|
steps (int): size of the constructed tensor
|
|||
|
|
base (float, optional): base of the logarithm function. Default: ``10.0``.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (torch.dtype, optional): the data type to perform the computation in.
|
|||
|
|
Default: if None, uses the global default dtype (see torch.get_default_dtype())
|
|||
|
|
when both :attr:`start` and :attr:`end` are real,
|
|||
|
|
and corresponding complex dtype when either is complex.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.logspace(start=-10, end=10, steps=5)
|
|||
|
|
tensor([ 1.0000e-10, 1.0000e-05, 1.0000e+00, 1.0000e+05, 1.0000e+10])
|
|||
|
|
>>> torch.logspace(start=0.1, end=1.0, steps=5)
|
|||
|
|
tensor([ 1.2589, 2.1135, 3.5481, 5.9566, 10.0000])
|
|||
|
|
>>> torch.logspace(start=0.1, end=1.0, steps=1)
|
|||
|
|
tensor([1.2589])
|
|||
|
|
>>> torch.logspace(start=2, end=2, steps=1, base=2)
|
|||
|
|
tensor([4.0])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def logspace(start: Tensor, end: Tensor, steps: _int, base: _float = 10.0, *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
logspace(start, end, steps, base=10.0, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
|
|||
|
|
Creates a one-dimensional tensor of size :attr:`steps` whose values are evenly
|
|||
|
|
spaced from :math:`{{\text{{base}}}}^{{\text{{start}}}}` to
|
|||
|
|
:math:`{{\text{{base}}}}^{{\text{{end}}}}`, inclusive, on a logarithmic scale
|
|||
|
|
with base :attr:`base`. That is, the values are:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
(\text{base}^{\text{start}},
|
|||
|
|
\text{base}^{(\text{start} + \frac{\text{end} - \text{start}}{ \text{steps} - 1})},
|
|||
|
|
\ldots,
|
|||
|
|
\text{base}^{(\text{start} + (\text{steps} - 2) * \frac{\text{end} - \text{start}}{ \text{steps} - 1})},
|
|||
|
|
\text{base}^{\text{end}})
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
From PyTorch 1.11 logspace requires the steps argument. Use steps=100 to restore the previous behavior.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
start (float or Tensor): the starting value for the set of points. If `Tensor`, it must be 0-dimensional
|
|||
|
|
end (float or Tensor): the ending value for the set of points. If `Tensor`, it must be 0-dimensional
|
|||
|
|
steps (int): size of the constructed tensor
|
|||
|
|
base (float, optional): base of the logarithm function. Default: ``10.0``.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (torch.dtype, optional): the data type to perform the computation in.
|
|||
|
|
Default: if None, uses the global default dtype (see torch.get_default_dtype())
|
|||
|
|
when both :attr:`start` and :attr:`end` are real,
|
|||
|
|
and corresponding complex dtype when either is complex.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.logspace(start=-10, end=10, steps=5)
|
|||
|
|
tensor([ 1.0000e-10, 1.0000e-05, 1.0000e+00, 1.0000e+05, 1.0000e+10])
|
|||
|
|
>>> torch.logspace(start=0.1, end=1.0, steps=5)
|
|||
|
|
tensor([ 1.2589, 2.1135, 3.5481, 5.9566, 10.0000])
|
|||
|
|
>>> torch.logspace(start=0.1, end=1.0, steps=1)
|
|||
|
|
tensor([1.2589])
|
|||
|
|
>>> torch.logspace(start=2, end=2, steps=1, base=2)
|
|||
|
|
tensor([4.0])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def logspace(start: Union[Number, _complex], end: Tensor, steps: _int, base: _float = 10.0, *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
logspace(start, end, steps, base=10.0, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
|
|||
|
|
Creates a one-dimensional tensor of size :attr:`steps` whose values are evenly
|
|||
|
|
spaced from :math:`{{\text{{base}}}}^{{\text{{start}}}}` to
|
|||
|
|
:math:`{{\text{{base}}}}^{{\text{{end}}}}`, inclusive, on a logarithmic scale
|
|||
|
|
with base :attr:`base`. That is, the values are:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
(\text{base}^{\text{start}},
|
|||
|
|
\text{base}^{(\text{start} + \frac{\text{end} - \text{start}}{ \text{steps} - 1})},
|
|||
|
|
\ldots,
|
|||
|
|
\text{base}^{(\text{start} + (\text{steps} - 2) * \frac{\text{end} - \text{start}}{ \text{steps} - 1})},
|
|||
|
|
\text{base}^{\text{end}})
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
From PyTorch 1.11 logspace requires the steps argument. Use steps=100 to restore the previous behavior.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
start (float or Tensor): the starting value for the set of points. If `Tensor`, it must be 0-dimensional
|
|||
|
|
end (float or Tensor): the ending value for the set of points. If `Tensor`, it must be 0-dimensional
|
|||
|
|
steps (int): size of the constructed tensor
|
|||
|
|
base (float, optional): base of the logarithm function. Default: ``10.0``.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (torch.dtype, optional): the data type to perform the computation in.
|
|||
|
|
Default: if None, uses the global default dtype (see torch.get_default_dtype())
|
|||
|
|
when both :attr:`start` and :attr:`end` are real,
|
|||
|
|
and corresponding complex dtype when either is complex.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.logspace(start=-10, end=10, steps=5)
|
|||
|
|
tensor([ 1.0000e-10, 1.0000e-05, 1.0000e+00, 1.0000e+05, 1.0000e+10])
|
|||
|
|
>>> torch.logspace(start=0.1, end=1.0, steps=5)
|
|||
|
|
tensor([ 1.2589, 2.1135, 3.5481, 5.9566, 10.0000])
|
|||
|
|
>>> torch.logspace(start=0.1, end=1.0, steps=1)
|
|||
|
|
tensor([1.2589])
|
|||
|
|
>>> torch.logspace(start=2, end=2, steps=1, base=2)
|
|||
|
|
tensor([4.0])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def logspace(start: Tensor, end: Union[Number, _complex], steps: _int, base: _float = 10.0, *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
logspace(start, end, steps, base=10.0, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
|
|||
|
|
Creates a one-dimensional tensor of size :attr:`steps` whose values are evenly
|
|||
|
|
spaced from :math:`{{\text{{base}}}}^{{\text{{start}}}}` to
|
|||
|
|
:math:`{{\text{{base}}}}^{{\text{{end}}}}`, inclusive, on a logarithmic scale
|
|||
|
|
with base :attr:`base`. That is, the values are:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
(\text{base}^{\text{start}},
|
|||
|
|
\text{base}^{(\text{start} + \frac{\text{end} - \text{start}}{ \text{steps} - 1})},
|
|||
|
|
\ldots,
|
|||
|
|
\text{base}^{(\text{start} + (\text{steps} - 2) * \frac{\text{end} - \text{start}}{ \text{steps} - 1})},
|
|||
|
|
\text{base}^{\text{end}})
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
From PyTorch 1.11 logspace requires the steps argument. Use steps=100 to restore the previous behavior.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
start (float or Tensor): the starting value for the set of points. If `Tensor`, it must be 0-dimensional
|
|||
|
|
end (float or Tensor): the ending value for the set of points. If `Tensor`, it must be 0-dimensional
|
|||
|
|
steps (int): size of the constructed tensor
|
|||
|
|
base (float, optional): base of the logarithm function. Default: ``10.0``.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (torch.dtype, optional): the data type to perform the computation in.
|
|||
|
|
Default: if None, uses the global default dtype (see torch.get_default_dtype())
|
|||
|
|
when both :attr:`start` and :attr:`end` are real,
|
|||
|
|
and corresponding complex dtype when either is complex.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.logspace(start=-10, end=10, steps=5)
|
|||
|
|
tensor([ 1.0000e-10, 1.0000e-05, 1.0000e+00, 1.0000e+05, 1.0000e+10])
|
|||
|
|
>>> torch.logspace(start=0.1, end=1.0, steps=5)
|
|||
|
|
tensor([ 1.2589, 2.1135, 3.5481, 5.9566, 10.0000])
|
|||
|
|
>>> torch.logspace(start=0.1, end=1.0, steps=1)
|
|||
|
|
tensor([1.2589])
|
|||
|
|
>>> torch.logspace(start=2, end=2, steps=1, base=2)
|
|||
|
|
tensor([4.0])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def logspace(start: Union[Number, _complex], end: Union[Number, _complex], steps: _int, base: _float = 10.0, *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
logspace(start, end, steps, base=10.0, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
|
|||
|
|
Creates a one-dimensional tensor of size :attr:`steps` whose values are evenly
|
|||
|
|
spaced from :math:`{{\text{{base}}}}^{{\text{{start}}}}` to
|
|||
|
|
:math:`{{\text{{base}}}}^{{\text{{end}}}}`, inclusive, on a logarithmic scale
|
|||
|
|
with base :attr:`base`. That is, the values are:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
(\text{base}^{\text{start}},
|
|||
|
|
\text{base}^{(\text{start} + \frac{\text{end} - \text{start}}{ \text{steps} - 1})},
|
|||
|
|
\ldots,
|
|||
|
|
\text{base}^{(\text{start} + (\text{steps} - 2) * \frac{\text{end} - \text{start}}{ \text{steps} - 1})},
|
|||
|
|
\text{base}^{\text{end}})
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
From PyTorch 1.11 logspace requires the steps argument. Use steps=100 to restore the previous behavior.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
start (float or Tensor): the starting value for the set of points. If `Tensor`, it must be 0-dimensional
|
|||
|
|
end (float or Tensor): the ending value for the set of points. If `Tensor`, it must be 0-dimensional
|
|||
|
|
steps (int): size of the constructed tensor
|
|||
|
|
base (float, optional): base of the logarithm function. Default: ``10.0``.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (torch.dtype, optional): the data type to perform the computation in.
|
|||
|
|
Default: if None, uses the global default dtype (see torch.get_default_dtype())
|
|||
|
|
when both :attr:`start` and :attr:`end` are real,
|
|||
|
|
and corresponding complex dtype when either is complex.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.logspace(start=-10, end=10, steps=5)
|
|||
|
|
tensor([ 1.0000e-10, 1.0000e-05, 1.0000e+00, 1.0000e+05, 1.0000e+10])
|
|||
|
|
>>> torch.logspace(start=0.1, end=1.0, steps=5)
|
|||
|
|
tensor([ 1.2589, 2.1135, 3.5481, 5.9566, 10.0000])
|
|||
|
|
>>> torch.logspace(start=0.1, end=1.0, steps=1)
|
|||
|
|
tensor([1.2589])
|
|||
|
|
>>> torch.logspace(start=2, end=2, steps=1, base=2)
|
|||
|
|
tensor([4.0])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def logsumexp(input: Tensor, dim: Union[_int, _size], keepdim: _bool = False, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
logsumexp(input, dim, keepdim=False, *, out=None)
|
|||
|
|
|
|||
|
|
Returns the log of summed exponentials of each row of the :attr:`input`
|
|||
|
|
tensor in the given dimension :attr:`dim`. The computation is numerically
|
|||
|
|
stabilized.
|
|||
|
|
|
|||
|
|
For summation index :math:`j` given by `dim` and other indices :math:`i`, the result is
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{logsumexp}(x)_{i} = \log \sum_j \exp(x_{ij})
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
dim (int or tuple of ints, optional): the dimension or dimensions to reduce.
|
|||
|
|
If ``None``, all dimensions are reduced.
|
|||
|
|
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(3, 3)
|
|||
|
|
>>> torch.logsumexp(a, 1)
|
|||
|
|
tensor([1.4907, 1.0593, 1.5696])
|
|||
|
|
>>> torch.dist(torch.logsumexp(a, 1), torch.log(torch.sum(torch.exp(a), 1)))
|
|||
|
|
tensor(1.6859e-07)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def logsumexp(input: Tensor, dim: Sequence[Union[str, ellipsis, None]], keepdim: _bool = False, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
logsumexp(input, dim, keepdim=False, *, out=None)
|
|||
|
|
|
|||
|
|
Returns the log of summed exponentials of each row of the :attr:`input`
|
|||
|
|
tensor in the given dimension :attr:`dim`. The computation is numerically
|
|||
|
|
stabilized.
|
|||
|
|
|
|||
|
|
For summation index :math:`j` given by `dim` and other indices :math:`i`, the result is
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{logsumexp}(x)_{i} = \log \sum_j \exp(x_{ij})
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
dim (int or tuple of ints, optional): the dimension or dimensions to reduce.
|
|||
|
|
If ``None``, all dimensions are reduced.
|
|||
|
|
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(3, 3)
|
|||
|
|
>>> torch.logsumexp(a, 1)
|
|||
|
|
tensor([1.4907, 1.0593, 1.5696])
|
|||
|
|
>>> torch.dist(torch.logsumexp(a, 1), torch.log(torch.sum(torch.exp(a), 1)))
|
|||
|
|
tensor(1.6859e-07)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def lstm(data: Tensor, batch_sizes: Tensor, hx: Union[Tuple[Tensor, ...], List[Tensor]], params: Union[Tuple[Tensor, ...], List[Tensor]], has_biases: _bool, num_layers: _int, dropout: _float, train: _bool, bidirectional: _bool) -> Tuple[Tensor, Tensor, Tensor]: ...
|
|||
|
|
@overload
|
|||
|
|
def lstm(input: Tensor, hx: Union[Tuple[Tensor, ...], List[Tensor]], params: Union[Tuple[Tensor, ...], List[Tensor]], has_biases: _bool, num_layers: _int, dropout: _float, train: _bool, bidirectional: _bool, batch_first: _bool) -> Tuple[Tensor, Tensor, Tensor]: ...
|
|||
|
|
def lstm_cell(input: Tensor, hx: Union[Tuple[Tensor, ...], List[Tensor]], w_ih: Tensor, w_hh: Tensor, b_ih: Optional[Tensor] = None, b_hh: Optional[Tensor] = None) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
@overload
|
|||
|
|
def lt(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
lt(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes :math:`\text{input} < \text{other}` element-wise.
|
|||
|
|
|
|||
|
|
|
|||
|
|
The second argument can be a number or a tensor whose shape is
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with the first argument.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to compare
|
|||
|
|
other (Tensor or float): the tensor or value to compare
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A boolean tensor that is True where :attr:`input` is less than :attr:`other` and False elsewhere
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.lt(torch.tensor([[1, 2], [3, 4]]), torch.tensor([[1, 1], [4, 4]]))
|
|||
|
|
tensor([[False, False], [True, False]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def lt(input: Tensor, other: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
lt(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes :math:`\text{input} < \text{other}` element-wise.
|
|||
|
|
|
|||
|
|
|
|||
|
|
The second argument can be a number or a tensor whose shape is
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with the first argument.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to compare
|
|||
|
|
other (Tensor or float): the tensor or value to compare
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A boolean tensor that is True where :attr:`input` is less than :attr:`other` and False elsewhere
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.lt(torch.tensor([[1, 2], [3, 4]]), torch.tensor([[1, 1], [4, 4]]))
|
|||
|
|
tensor([[False, False], [True, False]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def lu_solve(input: Tensor, LU_data: Tensor, LU_pivots: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
lu_solve(b, LU_data, LU_pivots, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the LU solve of the linear system :math:`Ax = b` using the partially pivoted
|
|||
|
|
LU factorization of A from :func:`~linalg.lu_factor`.
|
|||
|
|
|
|||
|
|
This function supports ``float``, ``double``, ``cfloat`` and ``cdouble`` dtypes for :attr:`input`.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
|
|||
|
|
:func:`torch.lu_solve` is deprecated in favor of :func:`torch.linalg.lu_solve`.
|
|||
|
|
:func:`torch.lu_solve` will be removed in a future PyTorch release.
|
|||
|
|
``X = torch.lu_solve(B, LU, pivots)`` should be replaced with
|
|||
|
|
|
|||
|
|
.. code:: python
|
|||
|
|
|
|||
|
|
X = linalg.lu_solve(LU, pivots, B)
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
b (Tensor): the RHS tensor of size :math:`(*, m, k)`, where :math:`*`
|
|||
|
|
is zero or more batch dimensions.
|
|||
|
|
LU_data (Tensor): the pivoted LU factorization of A from :meth:`~linalg.lu_factor` of size :math:`(*, m, m)`,
|
|||
|
|
where :math:`*` is zero or more batch dimensions.
|
|||
|
|
LU_pivots (IntTensor): the pivots of the LU factorization from :meth:`~linalg.lu_factor` of size :math:`(*, m)`,
|
|||
|
|
where :math:`*` is zero or more batch dimensions.
|
|||
|
|
The batch dimensions of :attr:`LU_pivots` must be equal to the batch dimensions of
|
|||
|
|
:attr:`LU_data`.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> A = torch.randn(2, 3, 3)
|
|||
|
|
>>> b = torch.randn(2, 3, 1)
|
|||
|
|
>>> LU, pivots = torch.linalg.lu_factor(A)
|
|||
|
|
>>> x = torch.lu_solve(b, LU, pivots)
|
|||
|
|
>>> torch.dist(A @ x, b)
|
|||
|
|
tensor(1.00000e-07 *
|
|||
|
|
2.8312)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def lu_unpack(LU_data: Tensor, LU_pivots: Tensor, unpack_data: _bool = True, unpack_pivots: _bool = True, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.lu_unpack:
|
|||
|
|
r"""
|
|||
|
|
lu_unpack(LU_data, LU_pivots, unpack_data=True, unpack_pivots=True, *, out=None) -> (Tensor, Tensor, Tensor)
|
|||
|
|
|
|||
|
|
Unpacks the LU decomposition returned by :func:`~linalg.lu_factor` into the `P, L, U` matrices.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`~linalg.lu` returns the matrices from the LU decomposition. Its gradient formula is more efficient
|
|||
|
|
than that of doing :func:`~linalg.lu_factor` followed by :func:`~linalg.lu_unpack`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
LU_data (Tensor): the packed LU factorization data
|
|||
|
|
LU_pivots (Tensor): the packed LU factorization pivots
|
|||
|
|
unpack_data (bool): flag indicating if the data should be unpacked.
|
|||
|
|
If ``False``, then the returned ``L`` and ``U`` are empty tensors.
|
|||
|
|
Default: ``True``
|
|||
|
|
unpack_pivots (bool): flag indicating if the pivots should be unpacked into a permutation matrix ``P``.
|
|||
|
|
If ``False``, then the returned ``P`` is an empty tensor.
|
|||
|
|
Default: ``True``
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): output tuple of three tensors. Ignored if `None`.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A namedtuple ``(P, L, U)``
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> A = torch.randn(2, 3, 3)
|
|||
|
|
>>> LU, pivots = torch.linalg.lu_factor(A)
|
|||
|
|
>>> P, L, U = torch.lu_unpack(LU, pivots)
|
|||
|
|
>>> # We can recover A from the factorization
|
|||
|
|
>>> A_ = P @ L @ U
|
|||
|
|
>>> torch.allclose(A, A_)
|
|||
|
|
True
|
|||
|
|
|
|||
|
|
>>> # LU factorization of a rectangular matrix:
|
|||
|
|
>>> A = torch.randn(2, 3, 2)
|
|||
|
|
>>> LU, pivots = torch.linalg.lu_factor(A)
|
|||
|
|
>>> P, L, U = torch.lu_unpack(LU, pivots)
|
|||
|
|
>>> # P, L, U are the same as returned by linalg.lu
|
|||
|
|
>>> P_, L_, U_ = torch.linalg.lu(A)
|
|||
|
|
>>> torch.allclose(P, P_) and torch.allclose(L, L_) and torch.allclose(U, U_)
|
|||
|
|
True
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def margin_ranking_loss(input1: Tensor, input2: Tensor, target: Tensor, margin: _float = 0.0, reduction: _int = 1) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def masked_fill(input: Tensor, mask: Tensor, value: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def masked_fill(input: Tensor, mask: Tensor, value: Union[Number, _complex]) -> Tensor: ...
|
|||
|
|
def masked_scatter(input: Tensor, mask: Tensor, source: Tensor) -> Tensor: ...
|
|||
|
|
def masked_select(input: Tensor, mask: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
masked_select(input, mask, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new 1-D tensor which indexes the :attr:`input` tensor according to
|
|||
|
|
the boolean mask :attr:`mask` which is a `BoolTensor`.
|
|||
|
|
|
|||
|
|
The shapes of the :attr:`mask` tensor and the :attr:`input` tensor don't need
|
|||
|
|
to match, but they must be :ref:`broadcastable <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
.. note:: The returned tensor does **not** use the same storage
|
|||
|
|
as the original tensor
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
mask (BoolTensor): the tensor containing the binary mask to index with
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(3, 4)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 0.3552, -2.3825, -0.8297, 0.3477],
|
|||
|
|
[-1.2035, 1.2252, 0.5002, 0.6248],
|
|||
|
|
[ 0.1307, -2.0608, 0.1244, 2.0139]])
|
|||
|
|
>>> mask = x.ge(0.5)
|
|||
|
|
>>> mask
|
|||
|
|
tensor([[False, False, False, False],
|
|||
|
|
[False, True, True, True],
|
|||
|
|
[False, False, False, True]])
|
|||
|
|
>>> torch.masked_select(x, mask)
|
|||
|
|
tensor([ 1.2252, 0.5002, 0.6248, 2.0139])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def matmul(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
matmul(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Matrix product of two tensors.
|
|||
|
|
|
|||
|
|
The behavior depends on the dimensionality of the tensors as follows:
|
|||
|
|
|
|||
|
|
- If both tensors are 1-dimensional, the dot product (scalar) is returned.
|
|||
|
|
- If both arguments are 2-dimensional, the matrix-matrix product is returned.
|
|||
|
|
- If the first argument is 1-dimensional and the second argument is 2-dimensional,
|
|||
|
|
a 1 is prepended to its dimension for the purpose of the matrix multiply.
|
|||
|
|
After the matrix multiply, the prepended dimension is removed.
|
|||
|
|
- If the first argument is 2-dimensional and the second argument is 1-dimensional,
|
|||
|
|
the matrix-vector product is returned.
|
|||
|
|
- If both arguments are at least 1-dimensional and at least one argument is
|
|||
|
|
N-dimensional (where N > 2), then a batched matrix multiply is returned. If the first
|
|||
|
|
argument is 1-dimensional, a 1 is prepended to its dimension for the purpose of the
|
|||
|
|
batched matrix multiply and removed after. If the second argument is 1-dimensional, a
|
|||
|
|
1 is appended to its dimension for the purpose of the batched matrix multiple and removed after.
|
|||
|
|
The non-matrix (i.e. batch) dimensions are :ref:`broadcasted <broadcasting-semantics>` (and thus
|
|||
|
|
must be broadcastable). For example, if :attr:`input` is a
|
|||
|
|
:math:`(j \times 1 \times n \times n)` tensor and :attr:`other` is a :math:`(k \times n \times n)`
|
|||
|
|
tensor, :attr:`out` will be a :math:`(j \times k \times n \times n)` tensor.
|
|||
|
|
|
|||
|
|
Note that the broadcasting logic only looks at the batch dimensions when determining if the inputs
|
|||
|
|
are broadcastable, and not the matrix dimensions. For example, if :attr:`input` is a
|
|||
|
|
:math:`(j \times 1 \times n \times m)` tensor and :attr:`other` is a :math:`(k \times m \times p)`
|
|||
|
|
tensor, these inputs are valid for broadcasting even though the final two dimensions (i.e. the
|
|||
|
|
matrix dimensions) are different. :attr:`out` will be a :math:`(j \times k \times n \times p)` tensor.
|
|||
|
|
|
|||
|
|
This operation has support for arguments with :ref:`sparse layouts<sparse-docs>`. In particular the
|
|||
|
|
matrix-matrix (both arguments 2-dimensional) supports sparse arguments with the same restrictions
|
|||
|
|
as :func:`torch.mm`
|
|||
|
|
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
Sparse support is a beta feature and some layout(s)/dtype/device combinations may not be supported,
|
|||
|
|
or may not have autograd support. If you notice missing functionality please
|
|||
|
|
open a feature request.
|
|||
|
|
|
|||
|
|
This operator supports :ref:`TensorFloat32<tf32_on_ampere>`.
|
|||
|
|
|
|||
|
|
On certain ROCm devices, when using float16 inputs this module will use :ref:`different precision<fp16_on_mi200>` for backward.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
The 1-dimensional dot product version of this function does not support an :attr:`out` parameter.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
input (Tensor): the first tensor to be multiplied
|
|||
|
|
other (Tensor): the second tensor to be multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> # vector x vector
|
|||
|
|
>>> tensor1 = torch.randn(3)
|
|||
|
|
>>> tensor2 = torch.randn(3)
|
|||
|
|
>>> torch.matmul(tensor1, tensor2).size()
|
|||
|
|
torch.Size([])
|
|||
|
|
>>> # matrix x vector
|
|||
|
|
>>> tensor1 = torch.randn(3, 4)
|
|||
|
|
>>> tensor2 = torch.randn(4)
|
|||
|
|
>>> torch.matmul(tensor1, tensor2).size()
|
|||
|
|
torch.Size([3])
|
|||
|
|
>>> # batched matrix x broadcasted vector
|
|||
|
|
>>> tensor1 = torch.randn(10, 3, 4)
|
|||
|
|
>>> tensor2 = torch.randn(4)
|
|||
|
|
>>> torch.matmul(tensor1, tensor2).size()
|
|||
|
|
torch.Size([10, 3])
|
|||
|
|
>>> # batched matrix x batched matrix
|
|||
|
|
>>> tensor1 = torch.randn(10, 3, 4)
|
|||
|
|
>>> tensor2 = torch.randn(10, 4, 5)
|
|||
|
|
>>> torch.matmul(tensor1, tensor2).size()
|
|||
|
|
torch.Size([10, 3, 5])
|
|||
|
|
>>> # batched matrix x broadcasted matrix
|
|||
|
|
>>> tensor1 = torch.randn(10, 3, 4)
|
|||
|
|
>>> tensor2 = torch.randn(4, 5)
|
|||
|
|
>>> torch.matmul(tensor1, tensor2).size()
|
|||
|
|
torch.Size([10, 3, 5])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def matrix_exp(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
matrix_exp(A) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.linalg.matrix_exp`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def matrix_power(input: Tensor, n: _int, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
matrix_power(input, n, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.linalg.matrix_power`
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def max(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
max(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the maximum value of all elements in the ``input`` tensor.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
This function produces deterministic (sub)gradients unlike ``max(dim=0)``
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(1, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.6763, 0.7445, -2.2369]])
|
|||
|
|
>>> torch.max(a)
|
|||
|
|
tensor(0.7445)
|
|||
|
|
|
|||
|
|
.. function:: max(input, dim, keepdim=False, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns a namedtuple ``(values, indices)`` where ``values`` is the maximum
|
|||
|
|
value of each row of the :attr:`input` tensor in the given dimension
|
|||
|
|
:attr:`dim`. And ``indices`` is the index location of each maximum value found
|
|||
|
|
(argmax).
|
|||
|
|
|
|||
|
|
If ``keepdim`` is ``True``, the output tensors are of the same size
|
|||
|
|
as ``input`` except in the dimension ``dim`` where they are of size 1.
|
|||
|
|
Otherwise, ``dim`` is squeezed (see :func:`torch.squeeze`), resulting
|
|||
|
|
in the output tensors having 1 fewer dimension than ``input``.
|
|||
|
|
|
|||
|
|
.. note:: If there are multiple maximal values in a reduced row then
|
|||
|
|
the indices of the first maximal value are returned.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not. Default: ``False``.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the result tuple of two output tensors (max, max_indices)
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[-1.2360, -0.2942, -0.1222, 0.8475],
|
|||
|
|
[ 1.1949, -1.1127, -2.2379, -0.6702],
|
|||
|
|
[ 1.5717, -0.9207, 0.1297, -1.8768],
|
|||
|
|
[-0.6172, 1.0036, -0.6060, -0.2432]])
|
|||
|
|
>>> torch.max(a, 1)
|
|||
|
|
torch.return_types.max(values=tensor([0.8475, 1.1949, 1.5717, 1.0036]), indices=tensor([3, 0, 0, 1]))
|
|||
|
|
|
|||
|
|
.. function:: max(input, other, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
See :func:`torch.maximum`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def max(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
max(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the maximum value of all elements in the ``input`` tensor.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
This function produces deterministic (sub)gradients unlike ``max(dim=0)``
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(1, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.6763, 0.7445, -2.2369]])
|
|||
|
|
>>> torch.max(a)
|
|||
|
|
tensor(0.7445)
|
|||
|
|
|
|||
|
|
.. function:: max(input, dim, keepdim=False, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns a namedtuple ``(values, indices)`` where ``values`` is the maximum
|
|||
|
|
value of each row of the :attr:`input` tensor in the given dimension
|
|||
|
|
:attr:`dim`. And ``indices`` is the index location of each maximum value found
|
|||
|
|
(argmax).
|
|||
|
|
|
|||
|
|
If ``keepdim`` is ``True``, the output tensors are of the same size
|
|||
|
|
as ``input`` except in the dimension ``dim`` where they are of size 1.
|
|||
|
|
Otherwise, ``dim`` is squeezed (see :func:`torch.squeeze`), resulting
|
|||
|
|
in the output tensors having 1 fewer dimension than ``input``.
|
|||
|
|
|
|||
|
|
.. note:: If there are multiple maximal values in a reduced row then
|
|||
|
|
the indices of the first maximal value are returned.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not. Default: ``False``.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the result tuple of two output tensors (max, max_indices)
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[-1.2360, -0.2942, -0.1222, 0.8475],
|
|||
|
|
[ 1.1949, -1.1127, -2.2379, -0.6702],
|
|||
|
|
[ 1.5717, -0.9207, 0.1297, -1.8768],
|
|||
|
|
[-0.6172, 1.0036, -0.6060, -0.2432]])
|
|||
|
|
>>> torch.max(a, 1)
|
|||
|
|
torch.return_types.max(values=tensor([0.8475, 1.1949, 1.5717, 1.0036]), indices=tensor([3, 0, 0, 1]))
|
|||
|
|
|
|||
|
|
.. function:: max(input, other, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
See :func:`torch.maximum`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def max(input: Tensor, dim: _int, keepdim: _bool = False, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.max:
|
|||
|
|
r"""
|
|||
|
|
max(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the maximum value of all elements in the ``input`` tensor.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
This function produces deterministic (sub)gradients unlike ``max(dim=0)``
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(1, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.6763, 0.7445, -2.2369]])
|
|||
|
|
>>> torch.max(a)
|
|||
|
|
tensor(0.7445)
|
|||
|
|
|
|||
|
|
.. function:: max(input, dim, keepdim=False, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns a namedtuple ``(values, indices)`` where ``values`` is the maximum
|
|||
|
|
value of each row of the :attr:`input` tensor in the given dimension
|
|||
|
|
:attr:`dim`. And ``indices`` is the index location of each maximum value found
|
|||
|
|
(argmax).
|
|||
|
|
|
|||
|
|
If ``keepdim`` is ``True``, the output tensors are of the same size
|
|||
|
|
as ``input`` except in the dimension ``dim`` where they are of size 1.
|
|||
|
|
Otherwise, ``dim`` is squeezed (see :func:`torch.squeeze`), resulting
|
|||
|
|
in the output tensors having 1 fewer dimension than ``input``.
|
|||
|
|
|
|||
|
|
.. note:: If there are multiple maximal values in a reduced row then
|
|||
|
|
the indices of the first maximal value are returned.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not. Default: ``False``.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the result tuple of two output tensors (max, max_indices)
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[-1.2360, -0.2942, -0.1222, 0.8475],
|
|||
|
|
[ 1.1949, -1.1127, -2.2379, -0.6702],
|
|||
|
|
[ 1.5717, -0.9207, 0.1297, -1.8768],
|
|||
|
|
[-0.6172, 1.0036, -0.6060, -0.2432]])
|
|||
|
|
>>> torch.max(a, 1)
|
|||
|
|
torch.return_types.max(values=tensor([0.8475, 1.1949, 1.5717, 1.0036]), indices=tensor([3, 0, 0, 1]))
|
|||
|
|
|
|||
|
|
.. function:: max(input, other, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
See :func:`torch.maximum`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def max(input: Tensor, dim: Union[str, ellipsis, None], keepdim: _bool = False, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.max:
|
|||
|
|
r"""
|
|||
|
|
max(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the maximum value of all elements in the ``input`` tensor.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
This function produces deterministic (sub)gradients unlike ``max(dim=0)``
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(1, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.6763, 0.7445, -2.2369]])
|
|||
|
|
>>> torch.max(a)
|
|||
|
|
tensor(0.7445)
|
|||
|
|
|
|||
|
|
.. function:: max(input, dim, keepdim=False, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns a namedtuple ``(values, indices)`` where ``values`` is the maximum
|
|||
|
|
value of each row of the :attr:`input` tensor in the given dimension
|
|||
|
|
:attr:`dim`. And ``indices`` is the index location of each maximum value found
|
|||
|
|
(argmax).
|
|||
|
|
|
|||
|
|
If ``keepdim`` is ``True``, the output tensors are of the same size
|
|||
|
|
as ``input`` except in the dimension ``dim`` where they are of size 1.
|
|||
|
|
Otherwise, ``dim`` is squeezed (see :func:`torch.squeeze`), resulting
|
|||
|
|
in the output tensors having 1 fewer dimension than ``input``.
|
|||
|
|
|
|||
|
|
.. note:: If there are multiple maximal values in a reduced row then
|
|||
|
|
the indices of the first maximal value are returned.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not. Default: ``False``.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the result tuple of two output tensors (max, max_indices)
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[-1.2360, -0.2942, -0.1222, 0.8475],
|
|||
|
|
[ 1.1949, -1.1127, -2.2379, -0.6702],
|
|||
|
|
[ 1.5717, -0.9207, 0.1297, -1.8768],
|
|||
|
|
[-0.6172, 1.0036, -0.6060, -0.2432]])
|
|||
|
|
>>> torch.max(a, 1)
|
|||
|
|
torch.return_types.max(values=tensor([0.8475, 1.1949, 1.5717, 1.0036]), indices=tensor([3, 0, 0, 1]))
|
|||
|
|
|
|||
|
|
.. function:: max(input, other, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
See :func:`torch.maximum`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def max_pool1d(input: Tensor, kernel_size: Union[_int, _size], stride: Union[_int, _size] = (), padding: Union[_int, _size] = 0, dilation: Union[_int, _size] = 1, ceil_mode: _bool = False) -> Tensor: ...
|
|||
|
|
def max_pool1d_with_indices(input: Tensor, kernel_size: Union[_int, _size], stride: Union[_int, _size] = (), padding: Union[_int, _size] = 0, dilation: Union[_int, _size] = 1, ceil_mode: _bool = False) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def max_pool2d(input: Tensor, kernel_size: Union[_int, _size], stride: Union[_int, _size] = (), padding: Union[_int, _size] = 0, dilation: Union[_int, _size] = 1, ceil_mode: _bool = False) -> Tensor: ...
|
|||
|
|
def max_pool3d(input: Tensor, kernel_size: Union[_int, _size], stride: Union[_int, _size] = (), padding: Union[_int, _size] = 0, dilation: Union[_int, _size] = 1, ceil_mode: _bool = False) -> Tensor: ...
|
|||
|
|
def maximum(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
maximum(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the element-wise maximum of :attr:`input` and :attr:`other`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If one of the elements being compared is a NaN, then that element is returned.
|
|||
|
|
:func:`maximum` is not supported for tensors with complex dtypes.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
other (Tensor): the second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor((1, 2, -1))
|
|||
|
|
>>> b = torch.tensor((3, 0, 4))
|
|||
|
|
>>> torch.maximum(a, b)
|
|||
|
|
tensor([3, 2, 4])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def mean(input: Tensor, *, dtype: Optional[_dtype] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
mean(input, *, dtype=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the mean value of all elements in the :attr:`input` tensor. Input must be floating point or complex.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor):
|
|||
|
|
the input tensor, either of floating point or complex dtype
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(1, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.2294, -0.5481, 1.3288]])
|
|||
|
|
>>> torch.mean(a)
|
|||
|
|
tensor(0.3367)
|
|||
|
|
|
|||
|
|
.. function:: mean(input, dim, keepdim=False, *, dtype=None, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns the mean value of each row of the :attr:`input` tensor in the given
|
|||
|
|
dimension :attr:`dim`. If :attr:`dim` is a list of dimensions,
|
|||
|
|
reduce over all of them.
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints): the dimension or dimensions to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.nanmean` computes the mean value of `non-NaN` elements.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[-0.3841, 0.6320, 0.4254, -0.7384],
|
|||
|
|
[-0.9644, 1.0131, -0.6549, -1.4279],
|
|||
|
|
[-0.2951, -1.3350, -0.7694, 0.5600],
|
|||
|
|
[ 1.0842, -0.9580, 0.3623, 0.2343]])
|
|||
|
|
>>> torch.mean(a, 1)
|
|||
|
|
tensor([-0.0163, -0.5085, -0.4599, 0.1807])
|
|||
|
|
>>> torch.mean(a, 1, True)
|
|||
|
|
tensor([[-0.0163],
|
|||
|
|
[-0.5085],
|
|||
|
|
[-0.4599],
|
|||
|
|
[ 0.1807]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def mean(input: Tensor, dim: Optional[Union[_int, _size]], keepdim: _bool = False, *, dtype: Optional[_dtype] = None, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
mean(input, *, dtype=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the mean value of all elements in the :attr:`input` tensor. Input must be floating point or complex.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor):
|
|||
|
|
the input tensor, either of floating point or complex dtype
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(1, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.2294, -0.5481, 1.3288]])
|
|||
|
|
>>> torch.mean(a)
|
|||
|
|
tensor(0.3367)
|
|||
|
|
|
|||
|
|
.. function:: mean(input, dim, keepdim=False, *, dtype=None, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns the mean value of each row of the :attr:`input` tensor in the given
|
|||
|
|
dimension :attr:`dim`. If :attr:`dim` is a list of dimensions,
|
|||
|
|
reduce over all of them.
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints): the dimension or dimensions to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.nanmean` computes the mean value of `non-NaN` elements.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[-0.3841, 0.6320, 0.4254, -0.7384],
|
|||
|
|
[-0.9644, 1.0131, -0.6549, -1.4279],
|
|||
|
|
[-0.2951, -1.3350, -0.7694, 0.5600],
|
|||
|
|
[ 1.0842, -0.9580, 0.3623, 0.2343]])
|
|||
|
|
>>> torch.mean(a, 1)
|
|||
|
|
tensor([-0.0163, -0.5085, -0.4599, 0.1807])
|
|||
|
|
>>> torch.mean(a, 1, True)
|
|||
|
|
tensor([[-0.0163],
|
|||
|
|
[-0.5085],
|
|||
|
|
[-0.4599],
|
|||
|
|
[ 0.1807]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def mean(input: Tensor, dim: Sequence[Union[str, ellipsis, None]], keepdim: _bool = False, *, dtype: Optional[_dtype] = None, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
mean(input, *, dtype=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the mean value of all elements in the :attr:`input` tensor. Input must be floating point or complex.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor):
|
|||
|
|
the input tensor, either of floating point or complex dtype
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(1, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.2294, -0.5481, 1.3288]])
|
|||
|
|
>>> torch.mean(a)
|
|||
|
|
tensor(0.3367)
|
|||
|
|
|
|||
|
|
.. function:: mean(input, dim, keepdim=False, *, dtype=None, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns the mean value of each row of the :attr:`input` tensor in the given
|
|||
|
|
dimension :attr:`dim`. If :attr:`dim` is a list of dimensions,
|
|||
|
|
reduce over all of them.
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints): the dimension or dimensions to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.nanmean` computes the mean value of `non-NaN` elements.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[-0.3841, 0.6320, 0.4254, -0.7384],
|
|||
|
|
[-0.9644, 1.0131, -0.6549, -1.4279],
|
|||
|
|
[-0.2951, -1.3350, -0.7694, 0.5600],
|
|||
|
|
[ 1.0842, -0.9580, 0.3623, 0.2343]])
|
|||
|
|
>>> torch.mean(a, 1)
|
|||
|
|
tensor([-0.0163, -0.5085, -0.4599, 0.1807])
|
|||
|
|
>>> torch.mean(a, 1, True)
|
|||
|
|
tensor([[-0.0163],
|
|||
|
|
[-0.5085],
|
|||
|
|
[-0.4599],
|
|||
|
|
[ 0.1807]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def median(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
median(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the median of the values in :attr:`input`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
The median is not unique for :attr:`input` tensors with an even number
|
|||
|
|
of elements. In this case the lower of the two medians is returned. To
|
|||
|
|
compute the mean of both medians, use :func:`torch.quantile` with ``q=0.5`` instead.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
This function produces deterministic (sub)gradients unlike ``median(dim=0)``
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(1, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 1.5219, -1.5212, 0.2202]])
|
|||
|
|
>>> torch.median(a)
|
|||
|
|
tensor(0.2202)
|
|||
|
|
|
|||
|
|
.. function:: median(input, dim=-1, keepdim=False, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns a namedtuple ``(values, indices)`` where ``values`` contains the median of each row of :attr:`input`
|
|||
|
|
in the dimension :attr:`dim`, and ``indices`` contains the index of the median values found in the dimension :attr:`dim`.
|
|||
|
|
|
|||
|
|
By default, :attr:`dim` is the last dimension of the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensors are of the same size
|
|||
|
|
as :attr:`input` except in the dimension :attr:`dim` where they are of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in
|
|||
|
|
the outputs tensor having 1 fewer dimension than :attr:`input`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
The median is not unique for :attr:`input` tensors with an even number
|
|||
|
|
of elements in the dimension :attr:`dim`. In this case the lower of the
|
|||
|
|
two medians is returned. To compute the mean of both medians in
|
|||
|
|
:attr:`input`, use :func:`torch.quantile` with ``q=0.5`` instead.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
``indices`` does not necessarily contain the first occurrence of each
|
|||
|
|
median value found, unless it is unique.
|
|||
|
|
The exact implementation details are device-specific.
|
|||
|
|
Do not expect the same result when run on CPU and GPU in general.
|
|||
|
|
For the same reason do not expect the gradients to be deterministic.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out ((Tensor, Tensor), optional): The first tensor will be populated with the median values and the second
|
|||
|
|
tensor, which must have dtype long, with their indices in the dimension
|
|||
|
|
:attr:`dim` of :attr:`input`.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 5)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.2505, -0.3982, -0.9948, 0.3518, -1.3131],
|
|||
|
|
[ 0.3180, -0.6993, 1.0436, 0.0438, 0.2270],
|
|||
|
|
[-0.2751, 0.7303, 0.2192, 0.3321, 0.2488],
|
|||
|
|
[ 1.0778, -1.9510, 0.7048, 0.4742, -0.7125]])
|
|||
|
|
>>> torch.median(a, 1)
|
|||
|
|
torch.return_types.median(values=tensor([-0.3982, 0.2270, 0.2488, 0.4742]), indices=tensor([1, 4, 4, 3]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def median(input: Tensor, dim: _int, keepdim: _bool = False, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.median:
|
|||
|
|
r"""
|
|||
|
|
median(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the median of the values in :attr:`input`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
The median is not unique for :attr:`input` tensors with an even number
|
|||
|
|
of elements. In this case the lower of the two medians is returned. To
|
|||
|
|
compute the mean of both medians, use :func:`torch.quantile` with ``q=0.5`` instead.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
This function produces deterministic (sub)gradients unlike ``median(dim=0)``
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(1, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 1.5219, -1.5212, 0.2202]])
|
|||
|
|
>>> torch.median(a)
|
|||
|
|
tensor(0.2202)
|
|||
|
|
|
|||
|
|
.. function:: median(input, dim=-1, keepdim=False, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns a namedtuple ``(values, indices)`` where ``values`` contains the median of each row of :attr:`input`
|
|||
|
|
in the dimension :attr:`dim`, and ``indices`` contains the index of the median values found in the dimension :attr:`dim`.
|
|||
|
|
|
|||
|
|
By default, :attr:`dim` is the last dimension of the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensors are of the same size
|
|||
|
|
as :attr:`input` except in the dimension :attr:`dim` where they are of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in
|
|||
|
|
the outputs tensor having 1 fewer dimension than :attr:`input`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
The median is not unique for :attr:`input` tensors with an even number
|
|||
|
|
of elements in the dimension :attr:`dim`. In this case the lower of the
|
|||
|
|
two medians is returned. To compute the mean of both medians in
|
|||
|
|
:attr:`input`, use :func:`torch.quantile` with ``q=0.5`` instead.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
``indices`` does not necessarily contain the first occurrence of each
|
|||
|
|
median value found, unless it is unique.
|
|||
|
|
The exact implementation details are device-specific.
|
|||
|
|
Do not expect the same result when run on CPU and GPU in general.
|
|||
|
|
For the same reason do not expect the gradients to be deterministic.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out ((Tensor, Tensor), optional): The first tensor will be populated with the median values and the second
|
|||
|
|
tensor, which must have dtype long, with their indices in the dimension
|
|||
|
|
:attr:`dim` of :attr:`input`.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 5)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.2505, -0.3982, -0.9948, 0.3518, -1.3131],
|
|||
|
|
[ 0.3180, -0.6993, 1.0436, 0.0438, 0.2270],
|
|||
|
|
[-0.2751, 0.7303, 0.2192, 0.3321, 0.2488],
|
|||
|
|
[ 1.0778, -1.9510, 0.7048, 0.4742, -0.7125]])
|
|||
|
|
>>> torch.median(a, 1)
|
|||
|
|
torch.return_types.median(values=tensor([-0.3982, 0.2270, 0.2488, 0.4742]), indices=tensor([1, 4, 4, 3]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def median(input: Tensor, dim: Union[str, ellipsis, None], keepdim: _bool = False, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.median:
|
|||
|
|
r"""
|
|||
|
|
median(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the median of the values in :attr:`input`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
The median is not unique for :attr:`input` tensors with an even number
|
|||
|
|
of elements. In this case the lower of the two medians is returned. To
|
|||
|
|
compute the mean of both medians, use :func:`torch.quantile` with ``q=0.5`` instead.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
This function produces deterministic (sub)gradients unlike ``median(dim=0)``
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(1, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 1.5219, -1.5212, 0.2202]])
|
|||
|
|
>>> torch.median(a)
|
|||
|
|
tensor(0.2202)
|
|||
|
|
|
|||
|
|
.. function:: median(input, dim=-1, keepdim=False, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns a namedtuple ``(values, indices)`` where ``values`` contains the median of each row of :attr:`input`
|
|||
|
|
in the dimension :attr:`dim`, and ``indices`` contains the index of the median values found in the dimension :attr:`dim`.
|
|||
|
|
|
|||
|
|
By default, :attr:`dim` is the last dimension of the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensors are of the same size
|
|||
|
|
as :attr:`input` except in the dimension :attr:`dim` where they are of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in
|
|||
|
|
the outputs tensor having 1 fewer dimension than :attr:`input`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
The median is not unique for :attr:`input` tensors with an even number
|
|||
|
|
of elements in the dimension :attr:`dim`. In this case the lower of the
|
|||
|
|
two medians is returned. To compute the mean of both medians in
|
|||
|
|
:attr:`input`, use :func:`torch.quantile` with ``q=0.5`` instead.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
``indices`` does not necessarily contain the first occurrence of each
|
|||
|
|
median value found, unless it is unique.
|
|||
|
|
The exact implementation details are device-specific.
|
|||
|
|
Do not expect the same result when run on CPU and GPU in general.
|
|||
|
|
For the same reason do not expect the gradients to be deterministic.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out ((Tensor, Tensor), optional): The first tensor will be populated with the median values and the second
|
|||
|
|
tensor, which must have dtype long, with their indices in the dimension
|
|||
|
|
:attr:`dim` of :attr:`input`.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 5)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.2505, -0.3982, -0.9948, 0.3518, -1.3131],
|
|||
|
|
[ 0.3180, -0.6993, 1.0436, 0.0438, 0.2270],
|
|||
|
|
[-0.2751, 0.7303, 0.2192, 0.3321, 0.2488],
|
|||
|
|
[ 1.0778, -1.9510, 0.7048, 0.4742, -0.7125]])
|
|||
|
|
>>> torch.median(a, 1)
|
|||
|
|
torch.return_types.median(values=tensor([-0.3982, 0.2270, 0.2488, 0.4742]), indices=tensor([1, 4, 4, 3]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def min(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
min(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the minimum value of all elements in the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
This function produces deterministic (sub)gradients unlike ``min(dim=0)``
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(1, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.6750, 1.0857, 1.7197]])
|
|||
|
|
>>> torch.min(a)
|
|||
|
|
tensor(0.6750)
|
|||
|
|
|
|||
|
|
.. function:: min(input, dim, keepdim=False, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns a namedtuple ``(values, indices)`` where ``values`` is the minimum
|
|||
|
|
value of each row of the :attr:`input` tensor in the given dimension
|
|||
|
|
:attr:`dim`. And ``indices`` is the index location of each minimum value found
|
|||
|
|
(argmin).
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensors are of the same size as
|
|||
|
|
:attr:`input` except in the dimension :attr:`dim` where they are of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in
|
|||
|
|
the output tensors having 1 fewer dimension than :attr:`input`.
|
|||
|
|
|
|||
|
|
.. note:: If there are multiple minimal values in a reduced row then
|
|||
|
|
the indices of the first minimal value are returned.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the tuple of two output tensors (min, min_indices)
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[-0.6248, 1.1334, -1.1899, -0.2803],
|
|||
|
|
[-1.4644, -0.2635, -0.3651, 0.6134],
|
|||
|
|
[ 0.2457, 0.0384, 1.0128, 0.7015],
|
|||
|
|
[-0.1153, 2.9849, 2.1458, 0.5788]])
|
|||
|
|
>>> torch.min(a, 1)
|
|||
|
|
torch.return_types.min(values=tensor([-1.1899, -1.4644, 0.0384, -0.1153]), indices=tensor([2, 0, 1, 0]))
|
|||
|
|
|
|||
|
|
.. function:: min(input, other, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
See :func:`torch.minimum`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def min(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
min(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the minimum value of all elements in the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
This function produces deterministic (sub)gradients unlike ``min(dim=0)``
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(1, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.6750, 1.0857, 1.7197]])
|
|||
|
|
>>> torch.min(a)
|
|||
|
|
tensor(0.6750)
|
|||
|
|
|
|||
|
|
.. function:: min(input, dim, keepdim=False, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns a namedtuple ``(values, indices)`` where ``values`` is the minimum
|
|||
|
|
value of each row of the :attr:`input` tensor in the given dimension
|
|||
|
|
:attr:`dim`. And ``indices`` is the index location of each minimum value found
|
|||
|
|
(argmin).
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensors are of the same size as
|
|||
|
|
:attr:`input` except in the dimension :attr:`dim` where they are of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in
|
|||
|
|
the output tensors having 1 fewer dimension than :attr:`input`.
|
|||
|
|
|
|||
|
|
.. note:: If there are multiple minimal values in a reduced row then
|
|||
|
|
the indices of the first minimal value are returned.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the tuple of two output tensors (min, min_indices)
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[-0.6248, 1.1334, -1.1899, -0.2803],
|
|||
|
|
[-1.4644, -0.2635, -0.3651, 0.6134],
|
|||
|
|
[ 0.2457, 0.0384, 1.0128, 0.7015],
|
|||
|
|
[-0.1153, 2.9849, 2.1458, 0.5788]])
|
|||
|
|
>>> torch.min(a, 1)
|
|||
|
|
torch.return_types.min(values=tensor([-1.1899, -1.4644, 0.0384, -0.1153]), indices=tensor([2, 0, 1, 0]))
|
|||
|
|
|
|||
|
|
.. function:: min(input, other, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
See :func:`torch.minimum`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def min(input: Tensor, dim: _int, keepdim: _bool = False, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.min:
|
|||
|
|
r"""
|
|||
|
|
min(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the minimum value of all elements in the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
This function produces deterministic (sub)gradients unlike ``min(dim=0)``
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(1, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.6750, 1.0857, 1.7197]])
|
|||
|
|
>>> torch.min(a)
|
|||
|
|
tensor(0.6750)
|
|||
|
|
|
|||
|
|
.. function:: min(input, dim, keepdim=False, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns a namedtuple ``(values, indices)`` where ``values`` is the minimum
|
|||
|
|
value of each row of the :attr:`input` tensor in the given dimension
|
|||
|
|
:attr:`dim`. And ``indices`` is the index location of each minimum value found
|
|||
|
|
(argmin).
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensors are of the same size as
|
|||
|
|
:attr:`input` except in the dimension :attr:`dim` where they are of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in
|
|||
|
|
the output tensors having 1 fewer dimension than :attr:`input`.
|
|||
|
|
|
|||
|
|
.. note:: If there are multiple minimal values in a reduced row then
|
|||
|
|
the indices of the first minimal value are returned.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the tuple of two output tensors (min, min_indices)
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[-0.6248, 1.1334, -1.1899, -0.2803],
|
|||
|
|
[-1.4644, -0.2635, -0.3651, 0.6134],
|
|||
|
|
[ 0.2457, 0.0384, 1.0128, 0.7015],
|
|||
|
|
[-0.1153, 2.9849, 2.1458, 0.5788]])
|
|||
|
|
>>> torch.min(a, 1)
|
|||
|
|
torch.return_types.min(values=tensor([-1.1899, -1.4644, 0.0384, -0.1153]), indices=tensor([2, 0, 1, 0]))
|
|||
|
|
|
|||
|
|
.. function:: min(input, other, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
See :func:`torch.minimum`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def min(input: Tensor, dim: Union[str, ellipsis, None], keepdim: _bool = False, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.min:
|
|||
|
|
r"""
|
|||
|
|
min(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the minimum value of all elements in the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
This function produces deterministic (sub)gradients unlike ``min(dim=0)``
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(1, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.6750, 1.0857, 1.7197]])
|
|||
|
|
>>> torch.min(a)
|
|||
|
|
tensor(0.6750)
|
|||
|
|
|
|||
|
|
.. function:: min(input, dim, keepdim=False, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns a namedtuple ``(values, indices)`` where ``values`` is the minimum
|
|||
|
|
value of each row of the :attr:`input` tensor in the given dimension
|
|||
|
|
:attr:`dim`. And ``indices`` is the index location of each minimum value found
|
|||
|
|
(argmin).
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensors are of the same size as
|
|||
|
|
:attr:`input` except in the dimension :attr:`dim` where they are of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in
|
|||
|
|
the output tensors having 1 fewer dimension than :attr:`input`.
|
|||
|
|
|
|||
|
|
.. note:: If there are multiple minimal values in a reduced row then
|
|||
|
|
the indices of the first minimal value are returned.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the tuple of two output tensors (min, min_indices)
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[-0.6248, 1.1334, -1.1899, -0.2803],
|
|||
|
|
[-1.4644, -0.2635, -0.3651, 0.6134],
|
|||
|
|
[ 0.2457, 0.0384, 1.0128, 0.7015],
|
|||
|
|
[-0.1153, 2.9849, 2.1458, 0.5788]])
|
|||
|
|
>>> torch.min(a, 1)
|
|||
|
|
torch.return_types.min(values=tensor([-1.1899, -1.4644, 0.0384, -0.1153]), indices=tensor([2, 0, 1, 0]))
|
|||
|
|
|
|||
|
|
.. function:: min(input, other, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
See :func:`torch.minimum`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def minimum(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
minimum(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the element-wise minimum of :attr:`input` and :attr:`other`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
If one of the elements being compared is a NaN, then that element is returned.
|
|||
|
|
:func:`minimum` is not supported for tensors with complex dtypes.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
other (Tensor): the second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor((1, 2, -1))
|
|||
|
|
>>> b = torch.tensor((3, 0, 4))
|
|||
|
|
>>> torch.minimum(a, b)
|
|||
|
|
tensor([1, 0, -1])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def miopen_batch_norm(input: Tensor, weight: Tensor, bias: Optional[Tensor], running_mean: Optional[Tensor], running_var: Optional[Tensor], training: _bool, exponential_average_factor: _float, epsilon: _float) -> Tuple[Tensor, Tensor, Tensor]: ...
|
|||
|
|
def miopen_convolution(input: Tensor, weight: Tensor, bias: Optional[Tensor], padding: Sequence[Union[_int, SymInt]], stride: Sequence[Union[_int, SymInt]], dilation: Sequence[Union[_int, SymInt]], groups: Union[_int, SymInt], benchmark: _bool, deterministic: _bool) -> Tensor: ...
|
|||
|
|
def miopen_convolution_add_relu(input: Tensor, weight: Tensor, z: Tensor, alpha: Optional[Union[Number, _complex]], bias: Optional[Tensor], stride: Sequence[Union[_int, SymInt]], padding: Sequence[Union[_int, SymInt]], dilation: Sequence[Union[_int, SymInt]], groups: Union[_int, SymInt]) -> Tensor: ...
|
|||
|
|
def miopen_convolution_relu(input: Tensor, weight: Tensor, bias: Optional[Tensor], stride: Sequence[Union[_int, SymInt]], padding: Sequence[Union[_int, SymInt]], dilation: Sequence[Union[_int, SymInt]], groups: Union[_int, SymInt]) -> Tensor: ...
|
|||
|
|
def miopen_convolution_transpose(input: Tensor, weight: Tensor, bias: Optional[Tensor], padding: Sequence[Union[_int, SymInt]], output_padding: Sequence[Union[_int, SymInt]], stride: Sequence[Union[_int, SymInt]], dilation: Sequence[Union[_int, SymInt]], groups: Union[_int, SymInt], benchmark: _bool, deterministic: _bool) -> Tensor: ...
|
|||
|
|
def miopen_depthwise_convolution(input: Tensor, weight: Tensor, bias: Optional[Tensor], padding: Sequence[Union[_int, SymInt]], stride: Sequence[Union[_int, SymInt]], dilation: Sequence[Union[_int, SymInt]], groups: Union[_int, SymInt], benchmark: _bool, deterministic: _bool) -> Tensor: ...
|
|||
|
|
def miopen_rnn(input: Tensor, weight: Union[Tuple[Tensor, ...], List[Tensor]], weight_stride0: _int, hx: Tensor, cx: Optional[Tensor], mode: _int, hidden_size: _int, num_layers: _int, batch_first: _bool, dropout: _float, train: _bool, bidirectional: _bool, batch_sizes: _size, dropout_state: Optional[Tensor]) -> Tuple[Tensor, Tensor, Tensor, Tensor, Tensor]: ...
|
|||
|
|
def mkldnn_adaptive_avg_pool2d(input: Tensor, output_size: Union[_int, _size], *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def mkldnn_convolution(input: Tensor, weight: Tensor, bias: Optional[Tensor], padding: Sequence[Union[_int, SymInt]], stride: Sequence[Union[_int, SymInt]], dilation: Sequence[Union[_int, SymInt]], groups: Union[_int, SymInt]) -> Tensor: ...
|
|||
|
|
def mkldnn_linear_backward_weights(grad_output: Tensor, input: Tensor, weight: Tensor, bias_defined: _bool) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def mkldnn_max_pool2d(input: Tensor, kernel_size: Union[_int, _size], stride: Union[_int, _size] = (), padding: Union[_int, _size] = 0, dilation: Union[_int, _size] = 1, ceil_mode: _bool = False) -> Tensor: ...
|
|||
|
|
def mkldnn_max_pool3d(input: Tensor, kernel_size: Union[_int, _size], stride: Union[_int, _size] = (), padding: Union[_int, _size] = 0, dilation: Union[_int, _size] = 1, ceil_mode: _bool = False) -> Tensor: ...
|
|||
|
|
def mkldnn_rnn_layer(input: Tensor, weight0: Tensor, weight1: Tensor, weight2: Tensor, weight3: Tensor, hx_: Tensor, cx_: Tensor, reverse: _bool, batch_sizes: _size, mode: _int, hidden_size: _int, num_layers: _int, has_biases: _bool, bidirectional: _bool, batch_first: _bool, train: _bool) -> Tuple[Tensor, Tensor, Tensor, Tensor]: ...
|
|||
|
|
def mm(input: Tensor, mat2: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
mm(input, mat2, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a matrix multiplication of the matrices :attr:`input` and :attr:`mat2`.
|
|||
|
|
|
|||
|
|
If :attr:`input` is a :math:`(n \times m)` tensor, :attr:`mat2` is a
|
|||
|
|
:math:`(m \times p)` tensor, :attr:`out` will be a :math:`(n \times p)` tensor.
|
|||
|
|
|
|||
|
|
.. note:: This function does not :ref:`broadcast <broadcasting-semantics>`.
|
|||
|
|
For broadcasting matrix products, see :func:`torch.matmul`.
|
|||
|
|
|
|||
|
|
Supports strided and sparse 2-D tensors as inputs, autograd with
|
|||
|
|
respect to strided inputs.
|
|||
|
|
|
|||
|
|
This operation has support for arguments with :ref:`sparse layouts<sparse-docs>`.
|
|||
|
|
If :attr:`out` is provided it's layout will be used. Otherwise, the result
|
|||
|
|
layout will be deduced from that of :attr:`input`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
Sparse support is a beta feature and some layout(s)/dtype/device combinations may not be supported,
|
|||
|
|
or may not have autograd support. If you notice missing functionality please
|
|||
|
|
open a feature request.
|
|||
|
|
|
|||
|
|
This operator supports :ref:`TensorFloat32<tf32_on_ampere>`.
|
|||
|
|
|
|||
|
|
On certain ROCm devices, when using float16 inputs this module will use :ref:`different precision<fp16_on_mi200>` for backward.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the first matrix to be matrix multiplied
|
|||
|
|
mat2 (Tensor): the second matrix to be matrix multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> mat1 = torch.randn(2, 3)
|
|||
|
|
>>> mat2 = torch.randn(3, 3)
|
|||
|
|
>>> torch.mm(mat1, mat2)
|
|||
|
|
tensor([[ 0.4851, 0.5037, -0.3633],
|
|||
|
|
[-0.0760, -3.6705, 2.4784]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def mode(input: Tensor, dim: _int = -1, keepdim: _bool = False, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.mode:
|
|||
|
|
r"""
|
|||
|
|
mode(input, dim=-1, keepdim=False, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
|
|||
|
|
Returns a namedtuple ``(values, indices)`` where ``values`` is the mode
|
|||
|
|
value of each row of the :attr:`input` tensor in the given dimension
|
|||
|
|
:attr:`dim`, i.e. a value which appears most often
|
|||
|
|
in that row, and ``indices`` is the index location of each mode value found.
|
|||
|
|
|
|||
|
|
By default, :attr:`dim` is the last dimension of the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensors are of the same size as
|
|||
|
|
:attr:`input` except in the dimension :attr:`dim` where they are of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting
|
|||
|
|
in the output tensors having 1 fewer dimension than :attr:`input`.
|
|||
|
|
|
|||
|
|
.. note:: This function is not defined for ``torch.cuda.Tensor`` yet.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the result tuple of two output tensors (values, indices)
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> b = torch.tensor(
|
|||
|
|
[[0, 0, 0, 2, 0, 0, 2],
|
|||
|
|
[0, 3, 0, 0, 2, 0, 1],
|
|||
|
|
[2, 2, 2, 0, 0, 0, 3],
|
|||
|
|
[2, 2, 3, 0, 1, 1, 0],
|
|||
|
|
[1, 1, 0, 0, 2, 0, 2]])
|
|||
|
|
>>> torch.mode(b, 0)
|
|||
|
|
torch.return_types.mode(
|
|||
|
|
values=tensor([0, 2, 0, 0, 0, 0, 2]),
|
|||
|
|
indices=tensor([1, 3, 4, 4, 2, 4, 4]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def mode(input: Tensor, dim: Union[str, ellipsis, None], keepdim: _bool = False, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.mode:
|
|||
|
|
r"""
|
|||
|
|
mode(input, dim=-1, keepdim=False, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
|
|||
|
|
Returns a namedtuple ``(values, indices)`` where ``values`` is the mode
|
|||
|
|
value of each row of the :attr:`input` tensor in the given dimension
|
|||
|
|
:attr:`dim`, i.e. a value which appears most often
|
|||
|
|
in that row, and ``indices`` is the index location of each mode value found.
|
|||
|
|
|
|||
|
|
By default, :attr:`dim` is the last dimension of the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensors are of the same size as
|
|||
|
|
:attr:`input` except in the dimension :attr:`dim` where they are of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting
|
|||
|
|
in the output tensors having 1 fewer dimension than :attr:`input`.
|
|||
|
|
|
|||
|
|
.. note:: This function is not defined for ``torch.cuda.Tensor`` yet.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the result tuple of two output tensors (values, indices)
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> b = torch.tensor(
|
|||
|
|
[[0, 0, 0, 2, 0, 0, 2],
|
|||
|
|
[0, 3, 0, 0, 2, 0, 1],
|
|||
|
|
[2, 2, 2, 0, 0, 0, 3],
|
|||
|
|
[2, 2, 3, 0, 1, 1, 0],
|
|||
|
|
[1, 1, 0, 0, 2, 0, 2]])
|
|||
|
|
>>> torch.mode(b, 0)
|
|||
|
|
torch.return_types.mode(
|
|||
|
|
values=tensor([0, 2, 0, 0, 0, 0, 2]),
|
|||
|
|
indices=tensor([1, 3, 4, 4, 2, 4, 4]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def moveaxis(input: Tensor, source: _int, destination: _int) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
moveaxis(input, source, destination) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.movedim`.
|
|||
|
|
|
|||
|
|
This function is equivalent to NumPy's moveaxis function.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> t = torch.randn(3,2,1)
|
|||
|
|
>>> t
|
|||
|
|
tensor([[[-0.3362],
|
|||
|
|
[-0.8437]],
|
|||
|
|
|
|||
|
|
[[-0.9627],
|
|||
|
|
[ 0.1727]],
|
|||
|
|
|
|||
|
|
[[ 0.5173],
|
|||
|
|
[-0.1398]]])
|
|||
|
|
>>> torch.moveaxis(t, 1, 0).shape
|
|||
|
|
torch.Size([2, 3, 1])
|
|||
|
|
>>> torch.moveaxis(t, 1, 0)
|
|||
|
|
tensor([[[-0.3362],
|
|||
|
|
[-0.9627],
|
|||
|
|
[ 0.5173]],
|
|||
|
|
|
|||
|
|
[[-0.8437],
|
|||
|
|
[ 0.1727],
|
|||
|
|
[-0.1398]]])
|
|||
|
|
>>> torch.moveaxis(t, (1, 2), (0, 1)).shape
|
|||
|
|
torch.Size([2, 1, 3])
|
|||
|
|
>>> torch.moveaxis(t, (1, 2), (0, 1))
|
|||
|
|
tensor([[[-0.3362, -0.9627, 0.5173]],
|
|||
|
|
|
|||
|
|
[[-0.8437, 0.1727, -0.1398]]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def moveaxis(input: Tensor, source: _size, destination: _size) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
moveaxis(input, source, destination) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.movedim`.
|
|||
|
|
|
|||
|
|
This function is equivalent to NumPy's moveaxis function.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> t = torch.randn(3,2,1)
|
|||
|
|
>>> t
|
|||
|
|
tensor([[[-0.3362],
|
|||
|
|
[-0.8437]],
|
|||
|
|
|
|||
|
|
[[-0.9627],
|
|||
|
|
[ 0.1727]],
|
|||
|
|
|
|||
|
|
[[ 0.5173],
|
|||
|
|
[-0.1398]]])
|
|||
|
|
>>> torch.moveaxis(t, 1, 0).shape
|
|||
|
|
torch.Size([2, 3, 1])
|
|||
|
|
>>> torch.moveaxis(t, 1, 0)
|
|||
|
|
tensor([[[-0.3362],
|
|||
|
|
[-0.9627],
|
|||
|
|
[ 0.5173]],
|
|||
|
|
|
|||
|
|
[[-0.8437],
|
|||
|
|
[ 0.1727],
|
|||
|
|
[-0.1398]]])
|
|||
|
|
>>> torch.moveaxis(t, (1, 2), (0, 1)).shape
|
|||
|
|
torch.Size([2, 1, 3])
|
|||
|
|
>>> torch.moveaxis(t, (1, 2), (0, 1))
|
|||
|
|
tensor([[[-0.3362, -0.9627, 0.5173]],
|
|||
|
|
|
|||
|
|
[[-0.8437, 0.1727, -0.1398]]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def movedim(input: Tensor, source: _int, destination: _int) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
movedim(input, source, destination) -> Tensor
|
|||
|
|
|
|||
|
|
Moves the dimension(s) of :attr:`input` at the position(s) in :attr:`source`
|
|||
|
|
to the position(s) in :attr:`destination`.
|
|||
|
|
|
|||
|
|
Other dimensions of :attr:`input` that are not explicitly moved remain in
|
|||
|
|
their original order and appear at the positions not specified in :attr:`destination`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
source (int or tuple of ints): Original positions of the dims to move. These must be unique.
|
|||
|
|
destination (int or tuple of ints): Destination positions for each of the original dims. These must also be unique.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> t = torch.randn(3,2,1)
|
|||
|
|
>>> t
|
|||
|
|
tensor([[[-0.3362],
|
|||
|
|
[-0.8437]],
|
|||
|
|
|
|||
|
|
[[-0.9627],
|
|||
|
|
[ 0.1727]],
|
|||
|
|
|
|||
|
|
[[ 0.5173],
|
|||
|
|
[-0.1398]]])
|
|||
|
|
>>> torch.movedim(t, 1, 0).shape
|
|||
|
|
torch.Size([2, 3, 1])
|
|||
|
|
>>> torch.movedim(t, 1, 0)
|
|||
|
|
tensor([[[-0.3362],
|
|||
|
|
[-0.9627],
|
|||
|
|
[ 0.5173]],
|
|||
|
|
|
|||
|
|
[[-0.8437],
|
|||
|
|
[ 0.1727],
|
|||
|
|
[-0.1398]]])
|
|||
|
|
>>> torch.movedim(t, (1, 2), (0, 1)).shape
|
|||
|
|
torch.Size([2, 1, 3])
|
|||
|
|
>>> torch.movedim(t, (1, 2), (0, 1))
|
|||
|
|
tensor([[[-0.3362, -0.9627, 0.5173]],
|
|||
|
|
|
|||
|
|
[[-0.8437, 0.1727, -0.1398]]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def movedim(input: Tensor, source: _size, destination: _size) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
movedim(input, source, destination) -> Tensor
|
|||
|
|
|
|||
|
|
Moves the dimension(s) of :attr:`input` at the position(s) in :attr:`source`
|
|||
|
|
to the position(s) in :attr:`destination`.
|
|||
|
|
|
|||
|
|
Other dimensions of :attr:`input` that are not explicitly moved remain in
|
|||
|
|
their original order and appear at the positions not specified in :attr:`destination`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
source (int or tuple of ints): Original positions of the dims to move. These must be unique.
|
|||
|
|
destination (int or tuple of ints): Destination positions for each of the original dims. These must also be unique.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> t = torch.randn(3,2,1)
|
|||
|
|
>>> t
|
|||
|
|
tensor([[[-0.3362],
|
|||
|
|
[-0.8437]],
|
|||
|
|
|
|||
|
|
[[-0.9627],
|
|||
|
|
[ 0.1727]],
|
|||
|
|
|
|||
|
|
[[ 0.5173],
|
|||
|
|
[-0.1398]]])
|
|||
|
|
>>> torch.movedim(t, 1, 0).shape
|
|||
|
|
torch.Size([2, 3, 1])
|
|||
|
|
>>> torch.movedim(t, 1, 0)
|
|||
|
|
tensor([[[-0.3362],
|
|||
|
|
[-0.9627],
|
|||
|
|
[ 0.5173]],
|
|||
|
|
|
|||
|
|
[[-0.8437],
|
|||
|
|
[ 0.1727],
|
|||
|
|
[-0.1398]]])
|
|||
|
|
>>> torch.movedim(t, (1, 2), (0, 1)).shape
|
|||
|
|
torch.Size([2, 1, 3])
|
|||
|
|
>>> torch.movedim(t, (1, 2), (0, 1))
|
|||
|
|
tensor([[[-0.3362, -0.9627, 0.5173]],
|
|||
|
|
|
|||
|
|
[[-0.8437, 0.1727, -0.1398]]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def msort(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
msort(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Sorts the elements of the :attr:`input` tensor along its first dimension
|
|||
|
|
in ascending order by value.
|
|||
|
|
|
|||
|
|
.. note:: `torch.msort(t)` is equivalent to `torch.sort(t, dim=0)[0]`.
|
|||
|
|
See also :func:`torch.sort`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> t = torch.randn(3, 4)
|
|||
|
|
>>> t
|
|||
|
|
tensor([[-0.1321, 0.4370, -1.2631, -1.1289],
|
|||
|
|
[-2.0527, -1.1250, 0.2275, 0.3077],
|
|||
|
|
[-0.0881, -0.1259, -0.5495, 1.0284]])
|
|||
|
|
>>> torch.msort(t)
|
|||
|
|
tensor([[-2.0527, -1.1250, -1.2631, -1.1289],
|
|||
|
|
[-0.1321, -0.1259, -0.5495, 0.3077],
|
|||
|
|
[-0.0881, 0.4370, 0.2275, 1.0284]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def mul(input: Union[Tensor, Number, _complex], other: Union[Tensor, Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
mul(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Multiplies :attr:`input` by :attr:`other`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \text{input}_i \times \text{other}_i
|
|||
|
|
|
|||
|
|
|
|||
|
|
Supports :ref:`broadcasting to a common shape <broadcasting-semantics>`,
|
|||
|
|
:ref:`type promotion <type-promotion-doc>`, and integer, float, and complex inputs.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
other (Tensor or Number) - the tensor or number to multiply input by.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 0.2015, -0.4255, 2.6087])
|
|||
|
|
>>> torch.mul(a, 100)
|
|||
|
|
tensor([ 20.1494, -42.5491, 260.8663])
|
|||
|
|
|
|||
|
|
>>> b = torch.randn(4, 1)
|
|||
|
|
>>> b
|
|||
|
|
tensor([[ 1.1207],
|
|||
|
|
[-0.3137],
|
|||
|
|
[ 0.0700],
|
|||
|
|
[ 0.8378]])
|
|||
|
|
>>> c = torch.randn(1, 4)
|
|||
|
|
>>> c
|
|||
|
|
tensor([[ 0.5146, 0.1216, -0.5244, 2.2382]])
|
|||
|
|
>>> torch.mul(b, c)
|
|||
|
|
tensor([[ 0.5767, 0.1363, -0.5877, 2.5083],
|
|||
|
|
[-0.1614, -0.0382, 0.1645, -0.7021],
|
|||
|
|
[ 0.0360, 0.0085, -0.0367, 0.1567],
|
|||
|
|
[ 0.4312, 0.1019, -0.4394, 1.8753]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def multinomial(input: Tensor, num_samples: _int, replacement: _bool = False, *, generator: Optional[Generator] = None, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
multinomial(input, num_samples, replacement=False, *, generator=None, out=None) -> LongTensor
|
|||
|
|
|
|||
|
|
Returns a tensor where each row contains :attr:`num_samples` indices sampled
|
|||
|
|
from the multinomial (a stricter definition would be multivariate,
|
|||
|
|
refer to torch.distributions.multinomial.Multinomial for more details)
|
|||
|
|
probability distribution located in the corresponding row
|
|||
|
|
of tensor :attr:`input`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
The rows of :attr:`input` do not need to sum to one (in which case we use
|
|||
|
|
the values as weights), but must be non-negative, finite and have
|
|||
|
|
a non-zero sum.
|
|||
|
|
|
|||
|
|
Indices are ordered from left to right according to when each was sampled
|
|||
|
|
(first samples are placed in first column).
|
|||
|
|
|
|||
|
|
If :attr:`input` is a vector, :attr:`out` is a vector of size :attr:`num_samples`.
|
|||
|
|
|
|||
|
|
If :attr:`input` is a matrix with `m` rows, :attr:`out` is an matrix of shape
|
|||
|
|
:math:`(m \times \text{num\_samples})`.
|
|||
|
|
|
|||
|
|
If replacement is ``True``, samples are drawn with replacement.
|
|||
|
|
|
|||
|
|
If not, they are drawn without replacement, which means that when a
|
|||
|
|
sample index is drawn for a row, it cannot be drawn again for that row.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
When drawn without replacement, :attr:`num_samples` must be lower than
|
|||
|
|
number of non-zero elements in :attr:`input` (or the min number of non-zero
|
|||
|
|
elements in each row of :attr:`input` if it is a matrix).
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor containing probabilities
|
|||
|
|
num_samples (int): number of samples to draw
|
|||
|
|
replacement (bool, optional): whether to draw with replacement or not
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> weights = torch.tensor([0, 10, 3, 0], dtype=torch.float) # create a tensor of weights
|
|||
|
|
>>> torch.multinomial(weights, 2)
|
|||
|
|
tensor([1, 2])
|
|||
|
|
>>> torch.multinomial(weights, 4) # ERROR!
|
|||
|
|
RuntimeError: invalid argument 2: invalid multinomial distribution (with replacement=False,
|
|||
|
|
not enough non-negative category to sample) at ../aten/src/TH/generic/THTensorRandom.cpp:320
|
|||
|
|
>>> torch.multinomial(weights, 4, replacement=True)
|
|||
|
|
tensor([ 2, 1, 1, 1])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def multiply(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
multiply(input, other, *, out=None)
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.mul`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def multiply(input: Tensor, other: Union[Number, _complex]) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
multiply(input, other, *, out=None)
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.mul`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def mv(input: Tensor, vec: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
mv(input, vec, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a matrix-vector product of the matrix :attr:`input` and the vector
|
|||
|
|
:attr:`vec`.
|
|||
|
|
|
|||
|
|
If :attr:`input` is a :math:`(n \times m)` tensor, :attr:`vec` is a 1-D tensor of
|
|||
|
|
size :math:`m`, :attr:`out` will be 1-D of size :math:`n`.
|
|||
|
|
|
|||
|
|
.. note:: This function does not :ref:`broadcast <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): matrix to be multiplied
|
|||
|
|
vec (Tensor): vector to be multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> mat = torch.randn(2, 3)
|
|||
|
|
>>> vec = torch.randn(3)
|
|||
|
|
>>> torch.mv(mat, vec)
|
|||
|
|
tensor([ 1.0404, -0.6361])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def mvlgamma(input: Tensor, p: _int, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
mvlgamma(input, p, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.special.multigammaln`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def nan_to_num(input: Tensor, nan: Optional[_float] = None, posinf: Optional[_float] = None, neginf: Optional[_float] = None, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
nan_to_num(input, nan=0.0, posinf=None, neginf=None, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Replaces :literal:`NaN`, positive infinity, and negative infinity values in :attr:`input`
|
|||
|
|
with the values specified by :attr:`nan`, :attr:`posinf`, and :attr:`neginf`, respectively.
|
|||
|
|
By default, :literal:`NaN`\ s are replaced with zero, positive infinity is replaced with the
|
|||
|
|
greatest finite value representable by :attr:`input`'s dtype, and negative infinity
|
|||
|
|
is replaced with the least finite value representable by :attr:`input`'s dtype.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
nan (Number, optional): the value to replace :literal:`NaN`\s with. Default is zero.
|
|||
|
|
posinf (Number, optional): if a Number, the value to replace positive infinity values with.
|
|||
|
|
If None, positive infinity values are replaced with the greatest finite value representable by :attr:`input`'s dtype.
|
|||
|
|
Default is None.
|
|||
|
|
neginf (Number, optional): if a Number, the value to replace negative infinity values with.
|
|||
|
|
If None, negative infinity values are replaced with the lowest finite value representable by :attr:`input`'s dtype.
|
|||
|
|
Default is None.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.tensor([float('nan'), float('inf'), -float('inf'), 3.14])
|
|||
|
|
>>> torch.nan_to_num(x)
|
|||
|
|
tensor([ 0.0000e+00, 3.4028e+38, -3.4028e+38, 3.1400e+00])
|
|||
|
|
>>> torch.nan_to_num(x, nan=2.0)
|
|||
|
|
tensor([ 2.0000e+00, 3.4028e+38, -3.4028e+38, 3.1400e+00])
|
|||
|
|
>>> torch.nan_to_num(x, nan=2.0, posinf=1.0)
|
|||
|
|
tensor([ 2.0000e+00, 1.0000e+00, -3.4028e+38, 3.1400e+00])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def nan_to_num_(input: Tensor, nan: Optional[_float] = None, posinf: Optional[_float] = None, neginf: Optional[_float] = None) -> Tensor: ...
|
|||
|
|
def nanmean(input: Tensor, dim: Optional[Union[_int, _size]] = None, keepdim: _bool = False, *, dtype: Optional[_dtype] = None, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
nanmean(input, dim=None, keepdim=False, *, dtype=None, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the mean of all `non-NaN` elements along the specified dimensions.
|
|||
|
|
|
|||
|
|
This function is identical to :func:`torch.mean` when there are no `NaN` values
|
|||
|
|
in the :attr:`input` tensor. In the presence of `NaN`, :func:`torch.mean` will
|
|||
|
|
propagate the `NaN` to the output whereas :func:`torch.nanmean` will ignore the
|
|||
|
|
`NaN` values (`torch.nanmean(a)` is equivalent to `torch.mean(a[~a.isnan()])`).
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
dim (int or tuple of ints, optional): the dimension or dimensions to reduce.
|
|||
|
|
If ``None``, all dimensions are reduced.
|
|||
|
|
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.mean` computes the mean value, propagating `NaN`.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.tensor([[torch.nan, 1, 2], [1, 2, 3]])
|
|||
|
|
>>> x.mean()
|
|||
|
|
tensor(nan)
|
|||
|
|
>>> x.nanmean()
|
|||
|
|
tensor(1.8000)
|
|||
|
|
>>> x.mean(dim=0)
|
|||
|
|
tensor([ nan, 1.5000, 2.5000])
|
|||
|
|
>>> x.nanmean(dim=0)
|
|||
|
|
tensor([1.0000, 1.5000, 2.5000])
|
|||
|
|
|
|||
|
|
# If all elements in the reduced dimensions are NaN then the result is NaN
|
|||
|
|
>>> torch.tensor([torch.nan]).nanmean()
|
|||
|
|
tensor(nan)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def nanmedian(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
nanmedian(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the median of the values in :attr:`input`, ignoring ``NaN`` values.
|
|||
|
|
|
|||
|
|
This function is identical to :func:`torch.median` when there are no ``NaN`` values in :attr:`input`.
|
|||
|
|
When :attr:`input` has one or more ``NaN`` values, :func:`torch.median` will always return ``NaN``,
|
|||
|
|
while this function will return the median of the non-``NaN`` elements in :attr:`input`.
|
|||
|
|
If all the elements in :attr:`input` are ``NaN`` it will also return ``NaN``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([1, float('nan'), 3, 2])
|
|||
|
|
>>> a.median()
|
|||
|
|
tensor(nan)
|
|||
|
|
>>> a.nanmedian()
|
|||
|
|
tensor(2.)
|
|||
|
|
|
|||
|
|
.. function:: nanmedian(input, dim=-1, keepdim=False, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns a namedtuple ``(values, indices)`` where ``values`` contains the median of each row of :attr:`input`
|
|||
|
|
in the dimension :attr:`dim`, ignoring ``NaN`` values, and ``indices`` contains the index of the median values
|
|||
|
|
found in the dimension :attr:`dim`.
|
|||
|
|
|
|||
|
|
This function is identical to :func:`torch.median` when there are no ``NaN`` values in a reduced row. When a reduced row has
|
|||
|
|
one or more ``NaN`` values, :func:`torch.median` will always reduce it to ``NaN``, while this function will reduce it to the
|
|||
|
|
median of the non-``NaN`` elements. If all the elements in a reduced row are ``NaN`` then it will be reduced to ``NaN``, too.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out ((Tensor, Tensor), optional): The first tensor will be populated with the median values and the second
|
|||
|
|
tensor, which must have dtype long, with their indices in the dimension
|
|||
|
|
:attr:`dim` of :attr:`input`.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([[2, 3, 1], [float('nan'), 1, float('nan')]])
|
|||
|
|
>>> a
|
|||
|
|
tensor([[2., 3., 1.],
|
|||
|
|
[nan, 1., nan]])
|
|||
|
|
>>> a.median(0)
|
|||
|
|
torch.return_types.median(values=tensor([nan, 1., nan]), indices=tensor([1, 1, 1]))
|
|||
|
|
>>> a.nanmedian(0)
|
|||
|
|
torch.return_types.nanmedian(values=tensor([2., 1., 1.]), indices=tensor([0, 1, 0]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def nanmedian(input: Tensor, dim: _int, keepdim: _bool = False, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.nanmedian:
|
|||
|
|
r"""
|
|||
|
|
nanmedian(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the median of the values in :attr:`input`, ignoring ``NaN`` values.
|
|||
|
|
|
|||
|
|
This function is identical to :func:`torch.median` when there are no ``NaN`` values in :attr:`input`.
|
|||
|
|
When :attr:`input` has one or more ``NaN`` values, :func:`torch.median` will always return ``NaN``,
|
|||
|
|
while this function will return the median of the non-``NaN`` elements in :attr:`input`.
|
|||
|
|
If all the elements in :attr:`input` are ``NaN`` it will also return ``NaN``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([1, float('nan'), 3, 2])
|
|||
|
|
>>> a.median()
|
|||
|
|
tensor(nan)
|
|||
|
|
>>> a.nanmedian()
|
|||
|
|
tensor(2.)
|
|||
|
|
|
|||
|
|
.. function:: nanmedian(input, dim=-1, keepdim=False, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns a namedtuple ``(values, indices)`` where ``values`` contains the median of each row of :attr:`input`
|
|||
|
|
in the dimension :attr:`dim`, ignoring ``NaN`` values, and ``indices`` contains the index of the median values
|
|||
|
|
found in the dimension :attr:`dim`.
|
|||
|
|
|
|||
|
|
This function is identical to :func:`torch.median` when there are no ``NaN`` values in a reduced row. When a reduced row has
|
|||
|
|
one or more ``NaN`` values, :func:`torch.median` will always reduce it to ``NaN``, while this function will reduce it to the
|
|||
|
|
median of the non-``NaN`` elements. If all the elements in a reduced row are ``NaN`` then it will be reduced to ``NaN``, too.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out ((Tensor, Tensor), optional): The first tensor will be populated with the median values and the second
|
|||
|
|
tensor, which must have dtype long, with their indices in the dimension
|
|||
|
|
:attr:`dim` of :attr:`input`.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([[2, 3, 1], [float('nan'), 1, float('nan')]])
|
|||
|
|
>>> a
|
|||
|
|
tensor([[2., 3., 1.],
|
|||
|
|
[nan, 1., nan]])
|
|||
|
|
>>> a.median(0)
|
|||
|
|
torch.return_types.median(values=tensor([nan, 1., nan]), indices=tensor([1, 1, 1]))
|
|||
|
|
>>> a.nanmedian(0)
|
|||
|
|
torch.return_types.nanmedian(values=tensor([2., 1., 1.]), indices=tensor([0, 1, 0]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def nanmedian(input: Tensor, dim: Union[str, ellipsis, None], keepdim: _bool = False, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.nanmedian:
|
|||
|
|
r"""
|
|||
|
|
nanmedian(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the median of the values in :attr:`input`, ignoring ``NaN`` values.
|
|||
|
|
|
|||
|
|
This function is identical to :func:`torch.median` when there are no ``NaN`` values in :attr:`input`.
|
|||
|
|
When :attr:`input` has one or more ``NaN`` values, :func:`torch.median` will always return ``NaN``,
|
|||
|
|
while this function will return the median of the non-``NaN`` elements in :attr:`input`.
|
|||
|
|
If all the elements in :attr:`input` are ``NaN`` it will also return ``NaN``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([1, float('nan'), 3, 2])
|
|||
|
|
>>> a.median()
|
|||
|
|
tensor(nan)
|
|||
|
|
>>> a.nanmedian()
|
|||
|
|
tensor(2.)
|
|||
|
|
|
|||
|
|
.. function:: nanmedian(input, dim=-1, keepdim=False, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns a namedtuple ``(values, indices)`` where ``values`` contains the median of each row of :attr:`input`
|
|||
|
|
in the dimension :attr:`dim`, ignoring ``NaN`` values, and ``indices`` contains the index of the median values
|
|||
|
|
found in the dimension :attr:`dim`.
|
|||
|
|
|
|||
|
|
This function is identical to :func:`torch.median` when there are no ``NaN`` values in a reduced row. When a reduced row has
|
|||
|
|
one or more ``NaN`` values, :func:`torch.median` will always reduce it to ``NaN``, while this function will reduce it to the
|
|||
|
|
median of the non-``NaN`` elements. If all the elements in a reduced row are ``NaN`` then it will be reduced to ``NaN``, too.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out ((Tensor, Tensor), optional): The first tensor will be populated with the median values and the second
|
|||
|
|
tensor, which must have dtype long, with their indices in the dimension
|
|||
|
|
:attr:`dim` of :attr:`input`.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([[2, 3, 1], [float('nan'), 1, float('nan')]])
|
|||
|
|
>>> a
|
|||
|
|
tensor([[2., 3., 1.],
|
|||
|
|
[nan, 1., nan]])
|
|||
|
|
>>> a.median(0)
|
|||
|
|
torch.return_types.median(values=tensor([nan, 1., nan]), indices=tensor([1, 1, 1]))
|
|||
|
|
>>> a.nanmedian(0)
|
|||
|
|
torch.return_types.nanmedian(values=tensor([2., 1., 1.]), indices=tensor([0, 1, 0]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def nanquantile(input: Tensor, q: Tensor, dim: Optional[_int] = None, keepdim: _bool = False, *, interpolation: str = "linear", out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
nanquantile(input, q, dim=None, keepdim=False, *, interpolation='linear', out=None) -> Tensor
|
|||
|
|
|
|||
|
|
This is a variant of :func:`torch.quantile` that "ignores" ``NaN`` values,
|
|||
|
|
computing the quantiles :attr:`q` as if ``NaN`` values in :attr:`input` did
|
|||
|
|
not exist. If all values in a reduced row are ``NaN`` then the quantiles for
|
|||
|
|
that reduction will be ``NaN``. See the documentation for :func:`torch.quantile`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
q (float or Tensor): a scalar or 1D tensor of quantile values in the range [0, 1]
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
interpolation (str): interpolation method to use when the desired quantile lies between two data points.
|
|||
|
|
Can be ``linear``, ``lower``, ``higher``, ``midpoint`` and ``nearest``.
|
|||
|
|
Default is ``linear``.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> t = torch.tensor([float('nan'), 1, 2])
|
|||
|
|
>>> t.quantile(0.5)
|
|||
|
|
tensor(nan)
|
|||
|
|
>>> t.nanquantile(0.5)
|
|||
|
|
tensor(1.5000)
|
|||
|
|
>>> t = torch.tensor([[float('nan'), float('nan')], [1, 2]])
|
|||
|
|
>>> t
|
|||
|
|
tensor([[nan, nan],
|
|||
|
|
[1., 2.]])
|
|||
|
|
>>> t.nanquantile(0.5, dim=0)
|
|||
|
|
tensor([1., 2.])
|
|||
|
|
>>> t.nanquantile(0.5, dim=1)
|
|||
|
|
tensor([ nan, 1.5000])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def nanquantile(input: Tensor, q: _float, dim: Optional[_int] = None, keepdim: _bool = False, *, interpolation: str = "linear", out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
nanquantile(input, q, dim=None, keepdim=False, *, interpolation='linear', out=None) -> Tensor
|
|||
|
|
|
|||
|
|
This is a variant of :func:`torch.quantile` that "ignores" ``NaN`` values,
|
|||
|
|
computing the quantiles :attr:`q` as if ``NaN`` values in :attr:`input` did
|
|||
|
|
not exist. If all values in a reduced row are ``NaN`` then the quantiles for
|
|||
|
|
that reduction will be ``NaN``. See the documentation for :func:`torch.quantile`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
q (float or Tensor): a scalar or 1D tensor of quantile values in the range [0, 1]
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
interpolation (str): interpolation method to use when the desired quantile lies between two data points.
|
|||
|
|
Can be ``linear``, ``lower``, ``higher``, ``midpoint`` and ``nearest``.
|
|||
|
|
Default is ``linear``.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> t = torch.tensor([float('nan'), 1, 2])
|
|||
|
|
>>> t.quantile(0.5)
|
|||
|
|
tensor(nan)
|
|||
|
|
>>> t.nanquantile(0.5)
|
|||
|
|
tensor(1.5000)
|
|||
|
|
>>> t = torch.tensor([[float('nan'), float('nan')], [1, 2]])
|
|||
|
|
>>> t
|
|||
|
|
tensor([[nan, nan],
|
|||
|
|
[1., 2.]])
|
|||
|
|
>>> t.nanquantile(0.5, dim=0)
|
|||
|
|
tensor([1., 2.])
|
|||
|
|
>>> t.nanquantile(0.5, dim=1)
|
|||
|
|
tensor([ nan, 1.5000])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def nansum(input: Tensor, dim: Optional[Union[_int, _size]] = None, keepdim: _bool = False, *, dtype: Optional[_dtype] = None, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
nansum(input, *, dtype=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the sum of all elements, treating Not a Numbers (NaNs) as zero.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([1., 2., float('nan'), 4.])
|
|||
|
|
>>> torch.nansum(a)
|
|||
|
|
tensor(7.)
|
|||
|
|
|
|||
|
|
.. function:: nansum(input, dim, keepdim=False, *, dtype=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns the sum of each row of the :attr:`input` tensor in the given
|
|||
|
|
dimension :attr:`dim`, treating Not a Numbers (NaNs) as zero.
|
|||
|
|
If :attr:`dim` is a list of dimensions, reduce over all of them.
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
dim (int or tuple of ints, optional): the dimension or dimensions to reduce.
|
|||
|
|
If ``None``, all dimensions are reduced.
|
|||
|
|
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.nansum(torch.tensor([1., float("nan")]))
|
|||
|
|
1.0
|
|||
|
|
>>> a = torch.tensor([[1, 2], [3., float("nan")]])
|
|||
|
|
>>> torch.nansum(a)
|
|||
|
|
tensor(6.)
|
|||
|
|
>>> torch.nansum(a, dim=0)
|
|||
|
|
tensor([4., 2.])
|
|||
|
|
>>> torch.nansum(a, dim=1)
|
|||
|
|
tensor([3., 3.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def narrow(input: Tensor, dim: _int, start: Tensor, length: Union[_int, SymInt]) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
narrow(input, dim, start, length) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor that is a narrowed version of :attr:`input` tensor. The
|
|||
|
|
dimension :attr:`dim` is input from :attr:`start` to ``start + length``. The
|
|||
|
|
returned tensor and :attr:`input` tensor share the same underlying storage.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to narrow
|
|||
|
|
dim (int): the dimension along which to narrow
|
|||
|
|
start (int or Tensor): index of the element to start the narrowed dimension
|
|||
|
|
from. Can be negative, which means indexing from the end of `dim`. If
|
|||
|
|
`Tensor`, it must be an 0-dim integral `Tensor` (bools not allowed)
|
|||
|
|
length (int): length of the narrowed dimension, must be weakly positive
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
|
|||
|
|
>>> torch.narrow(x, 0, 0, 2)
|
|||
|
|
tensor([[ 1, 2, 3],
|
|||
|
|
[ 4, 5, 6]])
|
|||
|
|
>>> torch.narrow(x, 1, 1, 2)
|
|||
|
|
tensor([[ 2, 3],
|
|||
|
|
[ 5, 6],
|
|||
|
|
[ 8, 9]])
|
|||
|
|
>>> torch.narrow(x, -1, torch.tensor(-1), 1)
|
|||
|
|
tensor([[3],
|
|||
|
|
[6],
|
|||
|
|
[9]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def narrow(input: Tensor, dim: _int, start: Union[_int, SymInt], length: Union[_int, SymInt]) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
narrow(input, dim, start, length) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor that is a narrowed version of :attr:`input` tensor. The
|
|||
|
|
dimension :attr:`dim` is input from :attr:`start` to ``start + length``. The
|
|||
|
|
returned tensor and :attr:`input` tensor share the same underlying storage.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to narrow
|
|||
|
|
dim (int): the dimension along which to narrow
|
|||
|
|
start (int or Tensor): index of the element to start the narrowed dimension
|
|||
|
|
from. Can be negative, which means indexing from the end of `dim`. If
|
|||
|
|
`Tensor`, it must be an 0-dim integral `Tensor` (bools not allowed)
|
|||
|
|
length (int): length of the narrowed dimension, must be weakly positive
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
|
|||
|
|
>>> torch.narrow(x, 0, 0, 2)
|
|||
|
|
tensor([[ 1, 2, 3],
|
|||
|
|
[ 4, 5, 6]])
|
|||
|
|
>>> torch.narrow(x, 1, 1, 2)
|
|||
|
|
tensor([[ 2, 3],
|
|||
|
|
[ 5, 6],
|
|||
|
|
[ 8, 9]])
|
|||
|
|
>>> torch.narrow(x, -1, torch.tensor(-1), 1)
|
|||
|
|
tensor([[3],
|
|||
|
|
[6],
|
|||
|
|
[9]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def narrow_copy(input: Tensor, dim: _int, start: Union[_int, SymInt], length: Union[_int, SymInt], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
narrow_copy(input, dim, start, length, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Same as :meth:`Tensor.narrow` except this returns a copy rather
|
|||
|
|
than shared storage. This is primarily for sparse tensors, which
|
|||
|
|
do not have a shared-storage narrow method.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to narrow
|
|||
|
|
dim (int): the dimension along which to narrow
|
|||
|
|
start (int): index of the element to start the narrowed dimension from. Can
|
|||
|
|
be negative, which means indexing from the end of `dim`
|
|||
|
|
length (int): length of the narrowed dimension, must be weakly positive
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
|
|||
|
|
>>> torch.narrow_copy(x, 0, 0, 2)
|
|||
|
|
tensor([[ 1, 2, 3],
|
|||
|
|
[ 4, 5, 6]])
|
|||
|
|
>>> torch.narrow_copy(x, 1, 1, 2)
|
|||
|
|
tensor([[ 2, 3],
|
|||
|
|
[ 5, 6],
|
|||
|
|
[ 8, 9]])
|
|||
|
|
>>> s = torch.arange(16).reshape(2, 2, 2, 2).to_sparse(2)
|
|||
|
|
>>> torch.narrow_copy(s, 0, 0, 1)
|
|||
|
|
tensor(indices=tensor([[0, 0],
|
|||
|
|
[0, 1]]),
|
|||
|
|
values=tensor([[[0, 1],
|
|||
|
|
[2, 3]],
|
|||
|
|
|
|||
|
|
[[4, 5],
|
|||
|
|
[6, 7]]]),
|
|||
|
|
size=(1, 2, 2, 2), nnz=2, layout=torch.sparse_coo)
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.narrow` for a non copy variant
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def native_batch_norm(input: Tensor, weight: Optional[Tensor], bias: Optional[Tensor], running_mean: Optional[Tensor], running_var: Optional[Tensor], training: _bool, momentum: _float, eps: _float, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> Tuple[Tensor, Tensor, Tensor]: ...
|
|||
|
|
def native_channel_shuffle(input: Tensor, groups: Union[_int, SymInt]) -> Tensor: ...
|
|||
|
|
def native_dropout(input: Tensor, p: _float, train: Optional[_bool]) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def native_group_norm(input: Tensor, weight: Optional[Tensor], bias: Optional[Tensor], N: Union[_int, SymInt], C: Union[_int, SymInt], HxW: Union[_int, SymInt], group: _int, eps: _float) -> Tuple[Tensor, Tensor, Tensor]: ...
|
|||
|
|
def native_layer_norm(input: Tensor, normalized_shape: Sequence[Union[_int, SymInt]], weight: Optional[Tensor], bias: Optional[Tensor], eps: _float) -> Tuple[Tensor, Tensor, Tensor]: ...
|
|||
|
|
@overload
|
|||
|
|
def native_norm(input: Tensor, p: Optional[Union[Number, _complex]], dim: Union[_int, _size], keepdim: _bool, dtype: Optional[_dtype]) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def native_norm(input: Tensor, p: Union[Number, _complex] = 2) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def ne(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
ne(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes :math:`\text{input} \neq \text{other}` element-wise.
|
|||
|
|
|
|||
|
|
|
|||
|
|
The second argument can be a number or a tensor whose shape is
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with the first argument.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to compare
|
|||
|
|
other (Tensor or float): the tensor or value to compare
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A boolean tensor that is True where :attr:`input` is not equal to :attr:`other` and False elsewhere
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.ne(torch.tensor([[1, 2], [3, 4]]), torch.tensor([[1, 1], [4, 4]]))
|
|||
|
|
tensor([[False, True], [True, False]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def ne(input: Tensor, other: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
ne(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes :math:`\text{input} \neq \text{other}` element-wise.
|
|||
|
|
|
|||
|
|
|
|||
|
|
The second argument can be a number or a tensor whose shape is
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>` with the first argument.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to compare
|
|||
|
|
other (Tensor or float): the tensor or value to compare
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A boolean tensor that is True where :attr:`input` is not equal to :attr:`other` and False elsewhere
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.ne(torch.tensor([[1, 2], [3, 4]]), torch.tensor([[1, 1], [4, 4]]))
|
|||
|
|
tensor([[False, True], [True, False]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def neg(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
neg(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the negative of the elements of :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out} = -1 \times \text{input}
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(5)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 0.0090, -0.2262, -0.0682, -0.2866, 0.3940])
|
|||
|
|
>>> torch.neg(a)
|
|||
|
|
tensor([-0.0090, 0.2262, 0.0682, 0.2866, -0.3940])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def neg_(input: Tensor) -> Tensor: ...
|
|||
|
|
def negative(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
negative(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.neg`
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def negative_(input: Tensor) -> Tensor: ...
|
|||
|
|
def nextafter(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
nextafter(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Return the next floating-point value after :attr:`input` towards :attr:`other`, elementwise.
|
|||
|
|
|
|||
|
|
The shapes of ``input`` and ``other`` must be
|
|||
|
|
:ref:`broadcastable <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the first input tensor
|
|||
|
|
other (Tensor): the second input tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> eps = torch.finfo(torch.float32).eps
|
|||
|
|
>>> torch.nextafter(torch.tensor([1.0, 2.0]), torch.tensor([2.0, 1.0])) == torch.tensor([eps + 1, 2 - eps])
|
|||
|
|
tensor([True, True])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def nonzero(input: Tensor, *, as_tuple: Literal[False] = False, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
nonzero(input, *, out=None, as_tuple=False) -> LongTensor or tuple of LongTensors
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
:func:`torch.nonzero(..., as_tuple=False) <torch.nonzero>` (default) returns a
|
|||
|
|
2-D tensor where each row is the index for a nonzero value.
|
|||
|
|
|
|||
|
|
:func:`torch.nonzero(..., as_tuple=True) <torch.nonzero>` returns a tuple of 1-D
|
|||
|
|
index tensors, allowing for advanced indexing, so ``x[x.nonzero(as_tuple=True)]``
|
|||
|
|
gives all nonzero values of tensor ``x``. Of the returned tuple, each index tensor
|
|||
|
|
contains nonzero indices for a certain dimension.
|
|||
|
|
|
|||
|
|
See below for more details on the two behaviors.
|
|||
|
|
|
|||
|
|
When :attr:`input` is on CUDA, :func:`torch.nonzero() <torch.nonzero>` causes
|
|||
|
|
host-device synchronization.
|
|||
|
|
|
|||
|
|
**When** :attr:`as_tuple` **is** ``False`` **(default)**:
|
|||
|
|
|
|||
|
|
Returns a tensor containing the indices of all non-zero elements of
|
|||
|
|
:attr:`input`. Each row in the result contains the indices of a non-zero
|
|||
|
|
element in :attr:`input`. The result is sorted lexicographically, with
|
|||
|
|
the last index changing the fastest (C-style).
|
|||
|
|
|
|||
|
|
If :attr:`input` has :math:`n` dimensions, then the resulting indices tensor
|
|||
|
|
:attr:`out` is of size :math:`(z \times n)`, where :math:`z` is the total number of
|
|||
|
|
non-zero elements in the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
**When** :attr:`as_tuple` **is** ``True``:
|
|||
|
|
|
|||
|
|
Returns a tuple of 1-D tensors, one for each dimension in :attr:`input`,
|
|||
|
|
each containing the indices (in that dimension) of all non-zero elements of
|
|||
|
|
:attr:`input` .
|
|||
|
|
|
|||
|
|
If :attr:`input` has :math:`n` dimensions, then the resulting tuple contains :math:`n`
|
|||
|
|
tensors of size :math:`z`, where :math:`z` is the total number of
|
|||
|
|
non-zero elements in the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
As a special case, when :attr:`input` has zero dimensions and a nonzero scalar
|
|||
|
|
value, it is treated as a one-dimensional tensor with one element.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (LongTensor, optional): the output tensor containing indices
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
LongTensor or tuple of LongTensor: If :attr:`as_tuple` is ``False``, the output
|
|||
|
|
tensor containing indices. If :attr:`as_tuple` is ``True``, one 1-D tensor for
|
|||
|
|
each dimension, containing the indices of each nonzero element along that
|
|||
|
|
dimension.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.nonzero(torch.tensor([1, 1, 1, 0, 1]))
|
|||
|
|
tensor([[ 0],
|
|||
|
|
[ 1],
|
|||
|
|
[ 2],
|
|||
|
|
[ 4]])
|
|||
|
|
>>> torch.nonzero(torch.tensor([[0.6, 0.0, 0.0, 0.0],
|
|||
|
|
... [0.0, 0.4, 0.0, 0.0],
|
|||
|
|
... [0.0, 0.0, 1.2, 0.0],
|
|||
|
|
... [0.0, 0.0, 0.0,-0.4]]))
|
|||
|
|
tensor([[ 0, 0],
|
|||
|
|
[ 1, 1],
|
|||
|
|
[ 2, 2],
|
|||
|
|
[ 3, 3]])
|
|||
|
|
>>> torch.nonzero(torch.tensor([1, 1, 1, 0, 1]), as_tuple=True)
|
|||
|
|
(tensor([0, 1, 2, 4]),)
|
|||
|
|
>>> torch.nonzero(torch.tensor([[0.6, 0.0, 0.0, 0.0],
|
|||
|
|
... [0.0, 0.4, 0.0, 0.0],
|
|||
|
|
... [0.0, 0.0, 1.2, 0.0],
|
|||
|
|
... [0.0, 0.0, 0.0,-0.4]]), as_tuple=True)
|
|||
|
|
(tensor([0, 1, 2, 3]), tensor([0, 1, 2, 3]))
|
|||
|
|
>>> torch.nonzero(torch.tensor(5), as_tuple=True)
|
|||
|
|
(tensor([0]),)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def nonzero(input: Tensor, *, as_tuple: Literal[True]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
nonzero(input, *, out=None, as_tuple=False) -> LongTensor or tuple of LongTensors
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
:func:`torch.nonzero(..., as_tuple=False) <torch.nonzero>` (default) returns a
|
|||
|
|
2-D tensor where each row is the index for a nonzero value.
|
|||
|
|
|
|||
|
|
:func:`torch.nonzero(..., as_tuple=True) <torch.nonzero>` returns a tuple of 1-D
|
|||
|
|
index tensors, allowing for advanced indexing, so ``x[x.nonzero(as_tuple=True)]``
|
|||
|
|
gives all nonzero values of tensor ``x``. Of the returned tuple, each index tensor
|
|||
|
|
contains nonzero indices for a certain dimension.
|
|||
|
|
|
|||
|
|
See below for more details on the two behaviors.
|
|||
|
|
|
|||
|
|
When :attr:`input` is on CUDA, :func:`torch.nonzero() <torch.nonzero>` causes
|
|||
|
|
host-device synchronization.
|
|||
|
|
|
|||
|
|
**When** :attr:`as_tuple` **is** ``False`` **(default)**:
|
|||
|
|
|
|||
|
|
Returns a tensor containing the indices of all non-zero elements of
|
|||
|
|
:attr:`input`. Each row in the result contains the indices of a non-zero
|
|||
|
|
element in :attr:`input`. The result is sorted lexicographically, with
|
|||
|
|
the last index changing the fastest (C-style).
|
|||
|
|
|
|||
|
|
If :attr:`input` has :math:`n` dimensions, then the resulting indices tensor
|
|||
|
|
:attr:`out` is of size :math:`(z \times n)`, where :math:`z` is the total number of
|
|||
|
|
non-zero elements in the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
**When** :attr:`as_tuple` **is** ``True``:
|
|||
|
|
|
|||
|
|
Returns a tuple of 1-D tensors, one for each dimension in :attr:`input`,
|
|||
|
|
each containing the indices (in that dimension) of all non-zero elements of
|
|||
|
|
:attr:`input` .
|
|||
|
|
|
|||
|
|
If :attr:`input` has :math:`n` dimensions, then the resulting tuple contains :math:`n`
|
|||
|
|
tensors of size :math:`z`, where :math:`z` is the total number of
|
|||
|
|
non-zero elements in the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
As a special case, when :attr:`input` has zero dimensions and a nonzero scalar
|
|||
|
|
value, it is treated as a one-dimensional tensor with one element.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (LongTensor, optional): the output tensor containing indices
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
LongTensor or tuple of LongTensor: If :attr:`as_tuple` is ``False``, the output
|
|||
|
|
tensor containing indices. If :attr:`as_tuple` is ``True``, one 1-D tensor for
|
|||
|
|
each dimension, containing the indices of each nonzero element along that
|
|||
|
|
dimension.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.nonzero(torch.tensor([1, 1, 1, 0, 1]))
|
|||
|
|
tensor([[ 0],
|
|||
|
|
[ 1],
|
|||
|
|
[ 2],
|
|||
|
|
[ 4]])
|
|||
|
|
>>> torch.nonzero(torch.tensor([[0.6, 0.0, 0.0, 0.0],
|
|||
|
|
... [0.0, 0.4, 0.0, 0.0],
|
|||
|
|
... [0.0, 0.0, 1.2, 0.0],
|
|||
|
|
... [0.0, 0.0, 0.0,-0.4]]))
|
|||
|
|
tensor([[ 0, 0],
|
|||
|
|
[ 1, 1],
|
|||
|
|
[ 2, 2],
|
|||
|
|
[ 3, 3]])
|
|||
|
|
>>> torch.nonzero(torch.tensor([1, 1, 1, 0, 1]), as_tuple=True)
|
|||
|
|
(tensor([0, 1, 2, 4]),)
|
|||
|
|
>>> torch.nonzero(torch.tensor([[0.6, 0.0, 0.0, 0.0],
|
|||
|
|
... [0.0, 0.4, 0.0, 0.0],
|
|||
|
|
... [0.0, 0.0, 1.2, 0.0],
|
|||
|
|
... [0.0, 0.0, 0.0,-0.4]]), as_tuple=True)
|
|||
|
|
(tensor([0, 1, 2, 3]), tensor([0, 1, 2, 3]))
|
|||
|
|
>>> torch.nonzero(torch.tensor(5), as_tuple=True)
|
|||
|
|
(tensor([0]),)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def nonzero_static(input: Tensor, *, size: _int, fill_value: _int = -1, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def norm_except_dim(v: Tensor, pow: _int = 2, dim: _int = 0) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def normal(mean: Tensor, std: Tensor, *, generator: Optional[Generator] = None, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
normal(mean, std, *, generator=None, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor of random numbers drawn from separate normal distributions
|
|||
|
|
whose mean and standard deviation are given.
|
|||
|
|
|
|||
|
|
The :attr:`mean` is a tensor with the mean of
|
|||
|
|
each output element's normal distribution
|
|||
|
|
|
|||
|
|
The :attr:`std` is a tensor with the standard deviation of
|
|||
|
|
each output element's normal distribution
|
|||
|
|
|
|||
|
|
The shapes of :attr:`mean` and :attr:`std` don't need to match, but the
|
|||
|
|
total number of elements in each tensor need to be the same.
|
|||
|
|
|
|||
|
|
.. note:: When the shapes do not match, the shape of :attr:`mean`
|
|||
|
|
is used as the shape for the returned output tensor
|
|||
|
|
|
|||
|
|
.. note:: When :attr:`std` is a CUDA tensor, this function synchronizes
|
|||
|
|
its device with the CPU.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
mean (Tensor): the tensor of per-element means
|
|||
|
|
std (Tensor): the tensor of per-element standard deviations
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.normal(mean=torch.arange(1., 11.), std=torch.arange(1, 0, -0.1))
|
|||
|
|
tensor([ 1.0425, 3.5672, 2.7969, 4.2925, 4.7229, 6.2134,
|
|||
|
|
8.0505, 8.1408, 9.0563, 10.0566])
|
|||
|
|
|
|||
|
|
.. function:: normal(mean=0.0, std, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Similar to the function above, but the means are shared among all drawn
|
|||
|
|
elements.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
mean (float, optional): the mean for all distributions
|
|||
|
|
std (Tensor): the tensor of per-element standard deviations
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.normal(mean=0.5, std=torch.arange(1., 6.))
|
|||
|
|
tensor([-1.2793, -1.0732, -2.0687, 5.1177, -1.2303])
|
|||
|
|
|
|||
|
|
.. function:: normal(mean, std=1.0, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Similar to the function above, but the standard deviations are shared among
|
|||
|
|
all drawn elements.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
mean (Tensor): the tensor of per-element means
|
|||
|
|
std (float, optional): the standard deviation for all distributions
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.normal(mean=torch.arange(1., 6.))
|
|||
|
|
tensor([ 1.1552, 2.6148, 2.6535, 5.8318, 4.2361])
|
|||
|
|
|
|||
|
|
.. function:: normal(mean, std, size, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Similar to the function above, but the means and standard deviations are shared
|
|||
|
|
among all drawn elements. The resulting tensor has size given by :attr:`size`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
mean (float): the mean for all distributions
|
|||
|
|
std (float): the standard deviation for all distributions
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.normal(2, 3, size=(1, 4))
|
|||
|
|
tensor([[-1.3987, -1.9544, 3.6048, 0.7909]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def normal(mean: Tensor, std: _float = 1, *, generator: Optional[Generator] = None, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
normal(mean, std, *, generator=None, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor of random numbers drawn from separate normal distributions
|
|||
|
|
whose mean and standard deviation are given.
|
|||
|
|
|
|||
|
|
The :attr:`mean` is a tensor with the mean of
|
|||
|
|
each output element's normal distribution
|
|||
|
|
|
|||
|
|
The :attr:`std` is a tensor with the standard deviation of
|
|||
|
|
each output element's normal distribution
|
|||
|
|
|
|||
|
|
The shapes of :attr:`mean` and :attr:`std` don't need to match, but the
|
|||
|
|
total number of elements in each tensor need to be the same.
|
|||
|
|
|
|||
|
|
.. note:: When the shapes do not match, the shape of :attr:`mean`
|
|||
|
|
is used as the shape for the returned output tensor
|
|||
|
|
|
|||
|
|
.. note:: When :attr:`std` is a CUDA tensor, this function synchronizes
|
|||
|
|
its device with the CPU.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
mean (Tensor): the tensor of per-element means
|
|||
|
|
std (Tensor): the tensor of per-element standard deviations
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.normal(mean=torch.arange(1., 11.), std=torch.arange(1, 0, -0.1))
|
|||
|
|
tensor([ 1.0425, 3.5672, 2.7969, 4.2925, 4.7229, 6.2134,
|
|||
|
|
8.0505, 8.1408, 9.0563, 10.0566])
|
|||
|
|
|
|||
|
|
.. function:: normal(mean=0.0, std, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Similar to the function above, but the means are shared among all drawn
|
|||
|
|
elements.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
mean (float, optional): the mean for all distributions
|
|||
|
|
std (Tensor): the tensor of per-element standard deviations
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.normal(mean=0.5, std=torch.arange(1., 6.))
|
|||
|
|
tensor([-1.2793, -1.0732, -2.0687, 5.1177, -1.2303])
|
|||
|
|
|
|||
|
|
.. function:: normal(mean, std=1.0, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Similar to the function above, but the standard deviations are shared among
|
|||
|
|
all drawn elements.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
mean (Tensor): the tensor of per-element means
|
|||
|
|
std (float, optional): the standard deviation for all distributions
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.normal(mean=torch.arange(1., 6.))
|
|||
|
|
tensor([ 1.1552, 2.6148, 2.6535, 5.8318, 4.2361])
|
|||
|
|
|
|||
|
|
.. function:: normal(mean, std, size, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Similar to the function above, but the means and standard deviations are shared
|
|||
|
|
among all drawn elements. The resulting tensor has size given by :attr:`size`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
mean (float): the mean for all distributions
|
|||
|
|
std (float): the standard deviation for all distributions
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.normal(2, 3, size=(1, 4))
|
|||
|
|
tensor([[-1.3987, -1.9544, 3.6048, 0.7909]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def normal(mean: _float, std: Tensor, *, generator: Optional[Generator] = None, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
normal(mean, std, *, generator=None, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor of random numbers drawn from separate normal distributions
|
|||
|
|
whose mean and standard deviation are given.
|
|||
|
|
|
|||
|
|
The :attr:`mean` is a tensor with the mean of
|
|||
|
|
each output element's normal distribution
|
|||
|
|
|
|||
|
|
The :attr:`std` is a tensor with the standard deviation of
|
|||
|
|
each output element's normal distribution
|
|||
|
|
|
|||
|
|
The shapes of :attr:`mean` and :attr:`std` don't need to match, but the
|
|||
|
|
total number of elements in each tensor need to be the same.
|
|||
|
|
|
|||
|
|
.. note:: When the shapes do not match, the shape of :attr:`mean`
|
|||
|
|
is used as the shape for the returned output tensor
|
|||
|
|
|
|||
|
|
.. note:: When :attr:`std` is a CUDA tensor, this function synchronizes
|
|||
|
|
its device with the CPU.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
mean (Tensor): the tensor of per-element means
|
|||
|
|
std (Tensor): the tensor of per-element standard deviations
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.normal(mean=torch.arange(1., 11.), std=torch.arange(1, 0, -0.1))
|
|||
|
|
tensor([ 1.0425, 3.5672, 2.7969, 4.2925, 4.7229, 6.2134,
|
|||
|
|
8.0505, 8.1408, 9.0563, 10.0566])
|
|||
|
|
|
|||
|
|
.. function:: normal(mean=0.0, std, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Similar to the function above, but the means are shared among all drawn
|
|||
|
|
elements.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
mean (float, optional): the mean for all distributions
|
|||
|
|
std (Tensor): the tensor of per-element standard deviations
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.normal(mean=0.5, std=torch.arange(1., 6.))
|
|||
|
|
tensor([-1.2793, -1.0732, -2.0687, 5.1177, -1.2303])
|
|||
|
|
|
|||
|
|
.. function:: normal(mean, std=1.0, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Similar to the function above, but the standard deviations are shared among
|
|||
|
|
all drawn elements.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
mean (Tensor): the tensor of per-element means
|
|||
|
|
std (float, optional): the standard deviation for all distributions
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.normal(mean=torch.arange(1., 6.))
|
|||
|
|
tensor([ 1.1552, 2.6148, 2.6535, 5.8318, 4.2361])
|
|||
|
|
|
|||
|
|
.. function:: normal(mean, std, size, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Similar to the function above, but the means and standard deviations are shared
|
|||
|
|
among all drawn elements. The resulting tensor has size given by :attr:`size`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
mean (float): the mean for all distributions
|
|||
|
|
std (float): the standard deviation for all distributions
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.normal(2, 3, size=(1, 4))
|
|||
|
|
tensor([[-1.3987, -1.9544, 3.6048, 0.7909]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def normal(mean: _float, std: _float, size: Sequence[Union[_int, SymInt]], *, generator: Optional[Generator] = None, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
normal(mean, std, *, generator=None, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor of random numbers drawn from separate normal distributions
|
|||
|
|
whose mean and standard deviation are given.
|
|||
|
|
|
|||
|
|
The :attr:`mean` is a tensor with the mean of
|
|||
|
|
each output element's normal distribution
|
|||
|
|
|
|||
|
|
The :attr:`std` is a tensor with the standard deviation of
|
|||
|
|
each output element's normal distribution
|
|||
|
|
|
|||
|
|
The shapes of :attr:`mean` and :attr:`std` don't need to match, but the
|
|||
|
|
total number of elements in each tensor need to be the same.
|
|||
|
|
|
|||
|
|
.. note:: When the shapes do not match, the shape of :attr:`mean`
|
|||
|
|
is used as the shape for the returned output tensor
|
|||
|
|
|
|||
|
|
.. note:: When :attr:`std` is a CUDA tensor, this function synchronizes
|
|||
|
|
its device with the CPU.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
mean (Tensor): the tensor of per-element means
|
|||
|
|
std (Tensor): the tensor of per-element standard deviations
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.normal(mean=torch.arange(1., 11.), std=torch.arange(1, 0, -0.1))
|
|||
|
|
tensor([ 1.0425, 3.5672, 2.7969, 4.2925, 4.7229, 6.2134,
|
|||
|
|
8.0505, 8.1408, 9.0563, 10.0566])
|
|||
|
|
|
|||
|
|
.. function:: normal(mean=0.0, std, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Similar to the function above, but the means are shared among all drawn
|
|||
|
|
elements.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
mean (float, optional): the mean for all distributions
|
|||
|
|
std (Tensor): the tensor of per-element standard deviations
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.normal(mean=0.5, std=torch.arange(1., 6.))
|
|||
|
|
tensor([-1.2793, -1.0732, -2.0687, 5.1177, -1.2303])
|
|||
|
|
|
|||
|
|
.. function:: normal(mean, std=1.0, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Similar to the function above, but the standard deviations are shared among
|
|||
|
|
all drawn elements.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
mean (Tensor): the tensor of per-element means
|
|||
|
|
std (float, optional): the standard deviation for all distributions
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.normal(mean=torch.arange(1., 6.))
|
|||
|
|
tensor([ 1.1552, 2.6148, 2.6535, 5.8318, 4.2361])
|
|||
|
|
|
|||
|
|
.. function:: normal(mean, std, size, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Similar to the function above, but the means and standard deviations are shared
|
|||
|
|
among all drawn elements. The resulting tensor has size given by :attr:`size`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
mean (float): the mean for all distributions
|
|||
|
|
std (float): the standard deviation for all distributions
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.normal(2, 3, size=(1, 4))
|
|||
|
|
tensor([[-1.3987, -1.9544, 3.6048, 0.7909]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def not_equal(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
not_equal(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.ne`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def not_equal(input: Tensor, other: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
not_equal(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.ne`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def nuclear_norm(input: Tensor, dim: Union[_int, _size], keepdim: _bool = False, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def nuclear_norm(input: Tensor, keepdim: _bool = False, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def numel(self: Tensor) -> _int:
|
|||
|
|
r"""
|
|||
|
|
numel(input) -> int
|
|||
|
|
|
|||
|
|
Returns the total number of elements in the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(1, 2, 3, 4, 5)
|
|||
|
|
>>> torch.numel(a)
|
|||
|
|
120
|
|||
|
|
>>> a = torch.zeros(4,4)
|
|||
|
|
>>> torch.numel(a)
|
|||
|
|
16
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def ones(size: Sequence[Union[_int, SymInt]], *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
ones(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with the scalar value `1`, with the shape defined
|
|||
|
|
by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.ones(2, 3)
|
|||
|
|
tensor([[ 1., 1., 1.],
|
|||
|
|
[ 1., 1., 1.]])
|
|||
|
|
|
|||
|
|
>>> torch.ones(5)
|
|||
|
|
tensor([ 1., 1., 1., 1., 1.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def ones(*size: _int, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
ones(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with the scalar value `1`, with the shape defined
|
|||
|
|
by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.ones(2, 3)
|
|||
|
|
tensor([[ 1., 1., 1.],
|
|||
|
|
[ 1., 1., 1.]])
|
|||
|
|
|
|||
|
|
>>> torch.ones(5)
|
|||
|
|
tensor([ 1., 1., 1., 1., 1.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def ones(size: _size, *, names: Optional[Sequence[Union[str, ellipsis, None]]], dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
ones(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with the scalar value `1`, with the shape defined
|
|||
|
|
by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.ones(2, 3)
|
|||
|
|
tensor([[ 1., 1., 1.],
|
|||
|
|
[ 1., 1., 1.]])
|
|||
|
|
|
|||
|
|
>>> torch.ones(5)
|
|||
|
|
tensor([ 1., 1., 1., 1., 1.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def ones(*size: _int, names: Optional[Sequence[Union[str, ellipsis, None]]], dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
ones(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with the scalar value `1`, with the shape defined
|
|||
|
|
by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.ones(2, 3)
|
|||
|
|
tensor([[ 1., 1., 1.],
|
|||
|
|
[ 1., 1., 1.]])
|
|||
|
|
|
|||
|
|
>>> torch.ones(5)
|
|||
|
|
tensor([ 1., 1., 1., 1., 1.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def ones_like(input: Tensor, *, memory_format: Optional[memory_format] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
ones_like(input, *, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with the scalar value `1`, with the same size as
|
|||
|
|
:attr:`input`. ``torch.ones_like(input)`` is equivalent to
|
|||
|
|
``torch.ones(input.size(), dtype=input.dtype, layout=input.layout, device=input.device)``.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
As of 0.4, this function does not support an :attr:`out` keyword. As an alternative,
|
|||
|
|
the old ``torch.ones_like(input, out=output)`` is equivalent to
|
|||
|
|
``torch.ones(input.size(), out=output)``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the size of :attr:`input` will determine size of the output tensor.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned Tensor.
|
|||
|
|
Default: if ``None``, defaults to the dtype of :attr:`input`.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned tensor.
|
|||
|
|
Default: if ``None``, defaults to the layout of :attr:`input`.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, defaults to the device of :attr:`input`.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
memory_format (:class:`torch.memory_format`, optional): the desired memory format of
|
|||
|
|
returned Tensor. Default: ``torch.preserve_format``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> input = torch.empty(2, 3)
|
|||
|
|
>>> torch.ones_like(input)
|
|||
|
|
tensor([[ 1., 1., 1.],
|
|||
|
|
[ 1., 1., 1.]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def orgqr(input: Tensor, input2: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
orgqr(input, tau) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.linalg.householder_product`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def ormqr(input: Tensor, input2: Tensor, input3: Tensor, left: _bool = True, transpose: _bool = False, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
ormqr(input, tau, other, left=True, transpose=False, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the matrix-matrix multiplication of a product of Householder matrices with a general matrix.
|
|||
|
|
|
|||
|
|
Multiplies a :math:`m \times n` matrix `C` (given by :attr:`other`) with a matrix `Q`,
|
|||
|
|
where `Q` is represented using Householder reflectors `(input, tau)`.
|
|||
|
|
See `Representation of Orthogonal or Unitary Matrices`_ for further details.
|
|||
|
|
|
|||
|
|
If :attr:`left` is `True` then `op(Q)` times `C` is computed, otherwise the result is `C` times `op(Q)`.
|
|||
|
|
When :attr:`left` is `True`, the implicit matrix `Q` has size :math:`m \times m`.
|
|||
|
|
It has size :math:`n \times n` otherwise.
|
|||
|
|
If :attr:`transpose` is `True` then `op` is the conjugate transpose operation, otherwise it's a no-op.
|
|||
|
|
|
|||
|
|
Supports inputs of float, double, cfloat and cdouble dtypes.
|
|||
|
|
Also supports batched inputs, and, if the input is batched, the output is batched with the same dimensions.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
:func:`torch.geqrf` can be used to form the Householder representation `(input, tau)` of matrix `Q`
|
|||
|
|
from the QR decomposition.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
This function supports backward but it is only fast when ``(input, tau)`` do not require gradients
|
|||
|
|
and/or ``tau.size(-1)`` is very small.
|
|||
|
|
``
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): tensor of shape `(*, mn, k)` where `*` is zero or more batch dimensions
|
|||
|
|
and `mn` equals to `m` or `n` depending on the :attr:`left`.
|
|||
|
|
tau (Tensor): tensor of shape `(*, min(mn, k))` where `*` is zero or more batch dimensions.
|
|||
|
|
other (Tensor): tensor of shape `(*, m, n)` where `*` is zero or more batch dimensions.
|
|||
|
|
left (bool): controls the order of multiplication.
|
|||
|
|
transpose (bool): controls whether the matrix `Q` is conjugate transposed or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output Tensor. Ignored if `None`. Default: `None`.
|
|||
|
|
|
|||
|
|
.. _Representation of Orthogonal or Unitary Matrices:
|
|||
|
|
https://www.netlib.org/lapack/lug/node128.html
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def outer(input: Tensor, vec2: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
outer(input, vec2, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Outer product of :attr:`input` and :attr:`vec2`.
|
|||
|
|
If :attr:`input` is a vector of size :math:`n` and :attr:`vec2` is a vector of
|
|||
|
|
size :math:`m`, then :attr:`out` must be a matrix of size :math:`(n \times m)`.
|
|||
|
|
|
|||
|
|
.. note:: This function does not :ref:`broadcast <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): 1-D input vector
|
|||
|
|
vec2 (Tensor): 1-D input vector
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): optional output matrix
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> v1 = torch.arange(1., 5.)
|
|||
|
|
>>> v2 = torch.arange(1., 4.)
|
|||
|
|
>>> torch.outer(v1, v2)
|
|||
|
|
tensor([[ 1., 2., 3.],
|
|||
|
|
[ 2., 4., 6.],
|
|||
|
|
[ 3., 6., 9.],
|
|||
|
|
[ 4., 8., 12.]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def pairwise_distance(x1: Tensor, x2: Tensor, p: _float = 2, eps: _float = 1e-06, keepdim: _bool = False) -> Tensor: ...
|
|||
|
|
def pdist(input: Tensor, p: _float = 2) -> Tensor: ...
|
|||
|
|
def permute(input: Tensor, dims: _size) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
permute(input, dims) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a view of the original tensor :attr:`input` with its dimensions permuted.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dims (tuple of int): The desired ordering of dimensions
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
>>> x = torch.randn(2, 3, 5)
|
|||
|
|
>>> x.size()
|
|||
|
|
torch.Size([2, 3, 5])
|
|||
|
|
>>> torch.permute(x, (2, 0, 1)).size()
|
|||
|
|
torch.Size([5, 2, 3])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def permute_copy(input: Tensor, dims: _size, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.permute`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def pinverse(input: Tensor, rcond: _float = 1e-15) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
pinverse(input, rcond=1e-15) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.linalg.pinv`
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def pixel_shuffle(input: Tensor, upscale_factor: _int) -> Tensor: ...
|
|||
|
|
def pixel_unshuffle(input: Tensor, downscale_factor: _int) -> Tensor: ...
|
|||
|
|
def poisson(input: Tensor, generator: Optional[Generator] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
poisson(input, generator=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor of the same size as :attr:`input` with each element
|
|||
|
|
sampled from a Poisson distribution with rate parameter given by the corresponding
|
|||
|
|
element in :attr:`input` i.e.,
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i \sim \text{Poisson}(\text{input}_i)
|
|||
|
|
|
|||
|
|
:attr:`input` must be non-negative.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor containing the rates of the Poisson distribution
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> rates = torch.rand(4, 4) * 5 # rate parameter between 0 and 5
|
|||
|
|
>>> torch.poisson(rates)
|
|||
|
|
tensor([[9., 1., 3., 5.],
|
|||
|
|
[8., 6., 6., 0.],
|
|||
|
|
[0., 4., 5., 3.],
|
|||
|
|
[2., 1., 4., 2.]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def poisson_nll_loss(input: Tensor, target: Tensor, log_input: _bool, full: _bool, eps: _float, reduction: _int) -> Tensor: ...
|
|||
|
|
def polar(abs: Tensor, angle: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
polar(abs, angle, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Constructs a complex tensor whose elements are Cartesian coordinates
|
|||
|
|
corresponding to the polar coordinates with absolute value :attr:`abs` and angle
|
|||
|
|
:attr:`angle`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out} = \text{abs} \cdot \cos(\text{angle}) + \text{abs} \cdot \sin(\text{angle}) \cdot j
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
`torch.polar` is similar to
|
|||
|
|
`std::polar <https://en.cppreference.com/w/cpp/numeric/complex/polar>`_
|
|||
|
|
and does not compute the polar decomposition
|
|||
|
|
of a complex tensor like Python's `cmath.polar` and SciPy's `linalg.polar` do.
|
|||
|
|
The behavior of this function is undefined if `abs` is negative or NaN, or if `angle` is
|
|||
|
|
infinite.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
abs (Tensor): The absolute value the complex tensor. Must be float or double.
|
|||
|
|
angle (Tensor): The angle of the complex tensor. Must be same dtype as
|
|||
|
|
:attr:`abs`.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor): If the inputs are ``torch.float32``, must be
|
|||
|
|
``torch.complex64``. If the inputs are ``torch.float64``, must be
|
|||
|
|
``torch.complex128``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> import numpy as np
|
|||
|
|
>>> abs = torch.tensor([1, 2], dtype=torch.float64)
|
|||
|
|
>>> angle = torch.tensor([np.pi / 2, 5 * np.pi / 4], dtype=torch.float64)
|
|||
|
|
>>> z = torch.polar(abs, angle)
|
|||
|
|
>>> z
|
|||
|
|
tensor([(0.0000+1.0000j), (-1.4142-1.4142j)], dtype=torch.complex128)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def polygamma(n: _int, input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
polygamma(n, input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.special.polygamma`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def positive(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
positive(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns :attr:`input`.
|
|||
|
|
Throws a runtime error if :attr:`input` is a bool tensor.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> t = torch.randn(5)
|
|||
|
|
>>> t
|
|||
|
|
tensor([ 0.0090, -0.2262, -0.0682, -0.2866, 0.3940])
|
|||
|
|
>>> torch.positive(t)
|
|||
|
|
tensor([ 0.0090, -0.2262, -0.0682, -0.2866, 0.3940])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def pow(input: Tensor, exponent: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
pow(input, exponent, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Takes the power of each element in :attr:`input` with :attr:`exponent` and
|
|||
|
|
returns a tensor with the result.
|
|||
|
|
|
|||
|
|
:attr:`exponent` can be either a single ``float`` number or a `Tensor`
|
|||
|
|
with the same number of elements as :attr:`input`.
|
|||
|
|
|
|||
|
|
When :attr:`exponent` is a scalar value, the operation applied is:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = x_i ^ \text{exponent}
|
|||
|
|
|
|||
|
|
When :attr:`exponent` is a tensor, the operation applied is:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = x_i ^ {\text{exponent}_i}
|
|||
|
|
|
|||
|
|
When :attr:`exponent` is a tensor, the shapes of :attr:`input`
|
|||
|
|
and :attr:`exponent` must be :ref:`broadcastable <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
exponent (float or tensor): the exponent value
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 0.4331, 1.2475, 0.6834, -0.2791])
|
|||
|
|
>>> torch.pow(a, 2)
|
|||
|
|
tensor([ 0.1875, 1.5561, 0.4670, 0.0779])
|
|||
|
|
>>> exp = torch.arange(1., 5.)
|
|||
|
|
|
|||
|
|
>>> a = torch.arange(1., 5.)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 1., 2., 3., 4.])
|
|||
|
|
>>> exp
|
|||
|
|
tensor([ 1., 2., 3., 4.])
|
|||
|
|
>>> torch.pow(a, exp)
|
|||
|
|
tensor([ 1., 4., 27., 256.])
|
|||
|
|
|
|||
|
|
.. function:: pow(self, exponent, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
:attr:`self` is a scalar ``float`` value, and :attr:`exponent` is a tensor.
|
|||
|
|
The returned tensor :attr:`out` is of the same shape as :attr:`exponent`
|
|||
|
|
|
|||
|
|
The operation applied is:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \text{self} ^ {\text{exponent}_i}
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
self (float): the scalar base value for the power operation
|
|||
|
|
exponent (Tensor): the exponent tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> exp = torch.arange(1., 5.)
|
|||
|
|
>>> base = 2
|
|||
|
|
>>> torch.pow(base, exp)
|
|||
|
|
tensor([ 2., 4., 8., 16.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def pow(self: Union[Number, _complex], exponent: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
pow(input, exponent, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Takes the power of each element in :attr:`input` with :attr:`exponent` and
|
|||
|
|
returns a tensor with the result.
|
|||
|
|
|
|||
|
|
:attr:`exponent` can be either a single ``float`` number or a `Tensor`
|
|||
|
|
with the same number of elements as :attr:`input`.
|
|||
|
|
|
|||
|
|
When :attr:`exponent` is a scalar value, the operation applied is:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = x_i ^ \text{exponent}
|
|||
|
|
|
|||
|
|
When :attr:`exponent` is a tensor, the operation applied is:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = x_i ^ {\text{exponent}_i}
|
|||
|
|
|
|||
|
|
When :attr:`exponent` is a tensor, the shapes of :attr:`input`
|
|||
|
|
and :attr:`exponent` must be :ref:`broadcastable <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
exponent (float or tensor): the exponent value
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 0.4331, 1.2475, 0.6834, -0.2791])
|
|||
|
|
>>> torch.pow(a, 2)
|
|||
|
|
tensor([ 0.1875, 1.5561, 0.4670, 0.0779])
|
|||
|
|
>>> exp = torch.arange(1., 5.)
|
|||
|
|
|
|||
|
|
>>> a = torch.arange(1., 5.)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 1., 2., 3., 4.])
|
|||
|
|
>>> exp
|
|||
|
|
tensor([ 1., 2., 3., 4.])
|
|||
|
|
>>> torch.pow(a, exp)
|
|||
|
|
tensor([ 1., 4., 27., 256.])
|
|||
|
|
|
|||
|
|
.. function:: pow(self, exponent, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
:attr:`self` is a scalar ``float`` value, and :attr:`exponent` is a tensor.
|
|||
|
|
The returned tensor :attr:`out` is of the same shape as :attr:`exponent`
|
|||
|
|
|
|||
|
|
The operation applied is:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \text{self} ^ {\text{exponent}_i}
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
self (float): the scalar base value for the power operation
|
|||
|
|
exponent (Tensor): the exponent tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> exp = torch.arange(1., 5.)
|
|||
|
|
>>> base = 2
|
|||
|
|
>>> torch.pow(base, exp)
|
|||
|
|
tensor([ 2., 4., 8., 16.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def pow(input: Tensor, exponent: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
pow(input, exponent, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Takes the power of each element in :attr:`input` with :attr:`exponent` and
|
|||
|
|
returns a tensor with the result.
|
|||
|
|
|
|||
|
|
:attr:`exponent` can be either a single ``float`` number or a `Tensor`
|
|||
|
|
with the same number of elements as :attr:`input`.
|
|||
|
|
|
|||
|
|
When :attr:`exponent` is a scalar value, the operation applied is:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = x_i ^ \text{exponent}
|
|||
|
|
|
|||
|
|
When :attr:`exponent` is a tensor, the operation applied is:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = x_i ^ {\text{exponent}_i}
|
|||
|
|
|
|||
|
|
When :attr:`exponent` is a tensor, the shapes of :attr:`input`
|
|||
|
|
and :attr:`exponent` must be :ref:`broadcastable <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
exponent (float or tensor): the exponent value
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 0.4331, 1.2475, 0.6834, -0.2791])
|
|||
|
|
>>> torch.pow(a, 2)
|
|||
|
|
tensor([ 0.1875, 1.5561, 0.4670, 0.0779])
|
|||
|
|
>>> exp = torch.arange(1., 5.)
|
|||
|
|
|
|||
|
|
>>> a = torch.arange(1., 5.)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 1., 2., 3., 4.])
|
|||
|
|
>>> exp
|
|||
|
|
tensor([ 1., 2., 3., 4.])
|
|||
|
|
>>> torch.pow(a, exp)
|
|||
|
|
tensor([ 1., 4., 27., 256.])
|
|||
|
|
|
|||
|
|
.. function:: pow(self, exponent, *, out=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
:attr:`self` is a scalar ``float`` value, and :attr:`exponent` is a tensor.
|
|||
|
|
The returned tensor :attr:`out` is of the same shape as :attr:`exponent`
|
|||
|
|
|
|||
|
|
The operation applied is:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \text{self} ^ {\text{exponent}_i}
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
self (float): the scalar base value for the power operation
|
|||
|
|
exponent (Tensor): the exponent tensor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> exp = torch.arange(1., 5.)
|
|||
|
|
>>> base = 2
|
|||
|
|
>>> torch.pow(base, exp)
|
|||
|
|
tensor([ 2., 4., 8., 16.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def prelu(input: Tensor, weight: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def prod(input: Tensor, *, dtype: Optional[_dtype] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
prod(input, *, dtype=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the product of all elements in the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(1, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[-0.8020, 0.5428, -1.5854]])
|
|||
|
|
>>> torch.prod(a)
|
|||
|
|
tensor(0.6902)
|
|||
|
|
|
|||
|
|
.. function:: prod(input, dim, keepdim=False, *, dtype=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns the product of each row of the :attr:`input` tensor in the given
|
|||
|
|
dimension :attr:`dim`.
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in
|
|||
|
|
the output tensor having 1 fewer dimension than :attr:`input`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 2)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.5261, -0.3837],
|
|||
|
|
[ 1.1857, -0.2498],
|
|||
|
|
[-1.1646, 0.0705],
|
|||
|
|
[ 1.1131, -1.0629]])
|
|||
|
|
>>> torch.prod(a, 1)
|
|||
|
|
tensor([-0.2018, -0.2962, -0.0821, -1.1831])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def prod(input: Tensor, dim: _int, keepdim: _bool = False, *, dtype: Optional[_dtype] = None, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
prod(input, *, dtype=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the product of all elements in the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(1, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[-0.8020, 0.5428, -1.5854]])
|
|||
|
|
>>> torch.prod(a)
|
|||
|
|
tensor(0.6902)
|
|||
|
|
|
|||
|
|
.. function:: prod(input, dim, keepdim=False, *, dtype=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns the product of each row of the :attr:`input` tensor in the given
|
|||
|
|
dimension :attr:`dim`.
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in
|
|||
|
|
the output tensor having 1 fewer dimension than :attr:`input`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 2)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.5261, -0.3837],
|
|||
|
|
[ 1.1857, -0.2498],
|
|||
|
|
[-1.1646, 0.0705],
|
|||
|
|
[ 1.1131, -1.0629]])
|
|||
|
|
>>> torch.prod(a, 1)
|
|||
|
|
tensor([-0.2018, -0.2962, -0.0821, -1.1831])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def prod(input: Tensor, dim: Union[str, ellipsis, None], keepdim: _bool = False, *, dtype: Optional[_dtype] = None, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
prod(input, *, dtype=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the product of all elements in the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(1, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[-0.8020, 0.5428, -1.5854]])
|
|||
|
|
>>> torch.prod(a)
|
|||
|
|
tensor(0.6902)
|
|||
|
|
|
|||
|
|
.. function:: prod(input, dim, keepdim=False, *, dtype=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns the product of each row of the :attr:`input` tensor in the given
|
|||
|
|
dimension :attr:`dim`.
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in
|
|||
|
|
the output tensor having 1 fewer dimension than :attr:`input`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 2)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.5261, -0.3837],
|
|||
|
|
[ 1.1857, -0.2498],
|
|||
|
|
[-1.1646, 0.0705],
|
|||
|
|
[ 1.1131, -1.0629]])
|
|||
|
|
>>> torch.prod(a, 1)
|
|||
|
|
tensor([-0.2018, -0.2962, -0.0821, -1.1831])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def promote_types(type1: _dtype, type2: _dtype) -> _dtype:
|
|||
|
|
r"""
|
|||
|
|
promote_types(type1, type2) -> dtype
|
|||
|
|
|
|||
|
|
Returns the :class:`torch.dtype` with the smallest size and scalar kind that is
|
|||
|
|
not smaller nor of lower kind than either `type1` or `type2`. See type promotion
|
|||
|
|
:ref:`documentation <type-promotion-doc>` for more information on the type
|
|||
|
|
promotion logic.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
type1 (:class:`torch.dtype`)
|
|||
|
|
type2 (:class:`torch.dtype`)
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.promote_types(torch.int32, torch.float32)
|
|||
|
|
torch.float32
|
|||
|
|
>>> torch.promote_types(torch.uint8, torch.long)
|
|||
|
|
torch.long
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def put(input: Tensor, index: Tensor, source: Tensor, accumulate: _bool = False) -> Tensor: ...
|
|||
|
|
def q_per_channel_axis(input: Tensor) -> _int: ...
|
|||
|
|
def q_per_channel_scales(input: Tensor) -> Tensor: ...
|
|||
|
|
def q_per_channel_zero_points(input: Tensor) -> Tensor: ...
|
|||
|
|
def q_scale(input: Tensor) -> _float: ...
|
|||
|
|
def q_zero_point(input: Tensor) -> _int: ...
|
|||
|
|
def qr(input: Tensor, some: _bool = True, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.qr:
|
|||
|
|
r"""
|
|||
|
|
qr(input, some=True, *, out=None) -> (Tensor, Tensor)
|
|||
|
|
|
|||
|
|
Computes the QR decomposition of a matrix or a batch of matrices :attr:`input`,
|
|||
|
|
and returns a namedtuple (Q, R) of tensors such that :math:`\text{input} = Q R`
|
|||
|
|
with :math:`Q` being an orthogonal matrix or batch of orthogonal matrices and
|
|||
|
|
:math:`R` being an upper triangular matrix or batch of upper triangular matrices.
|
|||
|
|
|
|||
|
|
If :attr:`some` is ``True``, then this function returns the thin (reduced) QR factorization.
|
|||
|
|
Otherwise, if :attr:`some` is ``False``, this function returns the complete QR factorization.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
|
|||
|
|
:func:`torch.qr` is deprecated in favor of :func:`torch.linalg.qr`
|
|||
|
|
and will be removed in a future PyTorch release. The boolean parameter :attr:`some` has been
|
|||
|
|
replaced with a string parameter :attr:`mode`.
|
|||
|
|
|
|||
|
|
``Q, R = torch.qr(A)`` should be replaced with
|
|||
|
|
|
|||
|
|
.. code:: python
|
|||
|
|
|
|||
|
|
Q, R = torch.linalg.qr(A)
|
|||
|
|
|
|||
|
|
``Q, R = torch.qr(A, some=False)`` should be replaced with
|
|||
|
|
|
|||
|
|
.. code:: python
|
|||
|
|
|
|||
|
|
Q, R = torch.linalg.qr(A, mode="complete")
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
If you plan to backpropagate through QR, note that the current backward implementation
|
|||
|
|
is only well-defined when the first :math:`\min(input.size(-1), input.size(-2))`
|
|||
|
|
columns of :attr:`input` are linearly independent.
|
|||
|
|
This behavior will probably change once QR supports pivoting.
|
|||
|
|
|
|||
|
|
.. note:: This function uses LAPACK for CPU inputs and MAGMA for CUDA inputs,
|
|||
|
|
and may produce different (valid) decompositions on different device types
|
|||
|
|
or different platforms.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor of size :math:`(*, m, n)` where `*` is zero or more
|
|||
|
|
batch dimensions consisting of matrices of dimension :math:`m \times n`.
|
|||
|
|
some (bool, optional): Set to ``True`` for reduced QR decomposition and ``False`` for
|
|||
|
|
complete QR decomposition. If `k = min(m, n)` then:
|
|||
|
|
|
|||
|
|
* ``some=True`` : returns `(Q, R)` with dimensions (m, k), (k, n) (default)
|
|||
|
|
|
|||
|
|
* ``'some=False'``: returns `(Q, R)` with dimensions (m, m), (m, n)
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): tuple of `Q` and `R` tensors.
|
|||
|
|
The dimensions of `Q` and `R` are detailed in the description of :attr:`some` above.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([[12., -51, 4], [6, 167, -68], [-4, 24, -41]])
|
|||
|
|
>>> q, r = torch.qr(a)
|
|||
|
|
>>> q
|
|||
|
|
tensor([[-0.8571, 0.3943, 0.3314],
|
|||
|
|
[-0.4286, -0.9029, -0.0343],
|
|||
|
|
[ 0.2857, -0.1714, 0.9429]])
|
|||
|
|
>>> r
|
|||
|
|
tensor([[ -14.0000, -21.0000, 14.0000],
|
|||
|
|
[ 0.0000, -175.0000, 70.0000],
|
|||
|
|
[ 0.0000, 0.0000, -35.0000]])
|
|||
|
|
>>> torch.mm(q, r).round()
|
|||
|
|
tensor([[ 12., -51., 4.],
|
|||
|
|
[ 6., 167., -68.],
|
|||
|
|
[ -4., 24., -41.]])
|
|||
|
|
>>> torch.mm(q.t(), q).round()
|
|||
|
|
tensor([[ 1., 0., 0.],
|
|||
|
|
[ 0., 1., -0.],
|
|||
|
|
[ 0., -0., 1.]])
|
|||
|
|
>>> a = torch.randn(3, 4, 5)
|
|||
|
|
>>> q, r = torch.qr(a, some=False)
|
|||
|
|
>>> torch.allclose(torch.matmul(q, r), a)
|
|||
|
|
True
|
|||
|
|
>>> torch.allclose(torch.matmul(q.mT, q), torch.eye(5))
|
|||
|
|
True
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def quantile(input: Tensor, q: Tensor, dim: Optional[_int] = None, keepdim: _bool = False, *, interpolation: str = "linear", out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
quantile(input, q, dim=None, keepdim=False, *, interpolation='linear', out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the q-th quantiles of each row of the :attr:`input` tensor along the dimension :attr:`dim`.
|
|||
|
|
|
|||
|
|
To compute the quantile, we map q in [0, 1] to the range of indices [0, n] to find the location
|
|||
|
|
of the quantile in the sorted input. If the quantile lies between two data points ``a < b`` with
|
|||
|
|
indices ``i`` and ``j`` in the sorted order, result is computed according to the given
|
|||
|
|
:attr:`interpolation` method as follows:
|
|||
|
|
|
|||
|
|
- ``linear``: ``a + (b - a) * fraction``, where ``fraction`` is the fractional part of the computed quantile index.
|
|||
|
|
- ``lower``: ``a``.
|
|||
|
|
- ``higher``: ``b``.
|
|||
|
|
- ``nearest``: ``a`` or ``b``, whichever's index is closer to the computed quantile index (rounding down for .5 fractions).
|
|||
|
|
- ``midpoint``: ``(a + b) / 2``.
|
|||
|
|
|
|||
|
|
If :attr:`q` is a 1D tensor, the first dimension of the output represents the quantiles and has size
|
|||
|
|
equal to the size of :attr:`q`, the remaining dimensions are what remains from the reduction.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
By default :attr:`dim` is ``None`` resulting in the :attr:`input` tensor being flattened before computation.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
q (float or Tensor): a scalar or 1D tensor of values in the range [0, 1].
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
interpolation (str): interpolation method to use when the desired quantile lies between two data points.
|
|||
|
|
Can be ``linear``, ``lower``, ``higher``, ``midpoint`` and ``nearest``.
|
|||
|
|
Default is ``linear``.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(2, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.0795, -1.2117, 0.9765],
|
|||
|
|
[ 1.1707, 0.6706, 0.4884]])
|
|||
|
|
>>> q = torch.tensor([0.25, 0.5, 0.75])
|
|||
|
|
>>> torch.quantile(a, q, dim=1, keepdim=True)
|
|||
|
|
tensor([[[-0.5661],
|
|||
|
|
[ 0.5795]],
|
|||
|
|
|
|||
|
|
[[ 0.0795],
|
|||
|
|
[ 0.6706]],
|
|||
|
|
|
|||
|
|
[[ 0.5280],
|
|||
|
|
[ 0.9206]]])
|
|||
|
|
>>> torch.quantile(a, q, dim=1, keepdim=True).shape
|
|||
|
|
torch.Size([3, 2, 1])
|
|||
|
|
>>> a = torch.arange(4.)
|
|||
|
|
>>> a
|
|||
|
|
tensor([0., 1., 2., 3.])
|
|||
|
|
>>> torch.quantile(a, 0.6, interpolation='linear')
|
|||
|
|
tensor(1.8000)
|
|||
|
|
>>> torch.quantile(a, 0.6, interpolation='lower')
|
|||
|
|
tensor(1.)
|
|||
|
|
>>> torch.quantile(a, 0.6, interpolation='higher')
|
|||
|
|
tensor(2.)
|
|||
|
|
>>> torch.quantile(a, 0.6, interpolation='midpoint')
|
|||
|
|
tensor(1.5000)
|
|||
|
|
>>> torch.quantile(a, 0.6, interpolation='nearest')
|
|||
|
|
tensor(2.)
|
|||
|
|
>>> torch.quantile(a, 0.4, interpolation='nearest')
|
|||
|
|
tensor(1.)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def quantile(input: Tensor, q: _float, dim: Optional[_int] = None, keepdim: _bool = False, *, interpolation: str = "linear", out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
quantile(input, q, dim=None, keepdim=False, *, interpolation='linear', out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the q-th quantiles of each row of the :attr:`input` tensor along the dimension :attr:`dim`.
|
|||
|
|
|
|||
|
|
To compute the quantile, we map q in [0, 1] to the range of indices [0, n] to find the location
|
|||
|
|
of the quantile in the sorted input. If the quantile lies between two data points ``a < b`` with
|
|||
|
|
indices ``i`` and ``j`` in the sorted order, result is computed according to the given
|
|||
|
|
:attr:`interpolation` method as follows:
|
|||
|
|
|
|||
|
|
- ``linear``: ``a + (b - a) * fraction``, where ``fraction`` is the fractional part of the computed quantile index.
|
|||
|
|
- ``lower``: ``a``.
|
|||
|
|
- ``higher``: ``b``.
|
|||
|
|
- ``nearest``: ``a`` or ``b``, whichever's index is closer to the computed quantile index (rounding down for .5 fractions).
|
|||
|
|
- ``midpoint``: ``(a + b) / 2``.
|
|||
|
|
|
|||
|
|
If :attr:`q` is a 1D tensor, the first dimension of the output represents the quantiles and has size
|
|||
|
|
equal to the size of :attr:`q`, the remaining dimensions are what remains from the reduction.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
By default :attr:`dim` is ``None`` resulting in the :attr:`input` tensor being flattened before computation.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
q (float or Tensor): a scalar or 1D tensor of values in the range [0, 1].
|
|||
|
|
dim (int): the dimension to reduce.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
interpolation (str): interpolation method to use when the desired quantile lies between two data points.
|
|||
|
|
Can be ``linear``, ``lower``, ``higher``, ``midpoint`` and ``nearest``.
|
|||
|
|
Default is ``linear``.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(2, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.0795, -1.2117, 0.9765],
|
|||
|
|
[ 1.1707, 0.6706, 0.4884]])
|
|||
|
|
>>> q = torch.tensor([0.25, 0.5, 0.75])
|
|||
|
|
>>> torch.quantile(a, q, dim=1, keepdim=True)
|
|||
|
|
tensor([[[-0.5661],
|
|||
|
|
[ 0.5795]],
|
|||
|
|
|
|||
|
|
[[ 0.0795],
|
|||
|
|
[ 0.6706]],
|
|||
|
|
|
|||
|
|
[[ 0.5280],
|
|||
|
|
[ 0.9206]]])
|
|||
|
|
>>> torch.quantile(a, q, dim=1, keepdim=True).shape
|
|||
|
|
torch.Size([3, 2, 1])
|
|||
|
|
>>> a = torch.arange(4.)
|
|||
|
|
>>> a
|
|||
|
|
tensor([0., 1., 2., 3.])
|
|||
|
|
>>> torch.quantile(a, 0.6, interpolation='linear')
|
|||
|
|
tensor(1.8000)
|
|||
|
|
>>> torch.quantile(a, 0.6, interpolation='lower')
|
|||
|
|
tensor(1.)
|
|||
|
|
>>> torch.quantile(a, 0.6, interpolation='higher')
|
|||
|
|
tensor(2.)
|
|||
|
|
>>> torch.quantile(a, 0.6, interpolation='midpoint')
|
|||
|
|
tensor(1.5000)
|
|||
|
|
>>> torch.quantile(a, 0.6, interpolation='nearest')
|
|||
|
|
tensor(2.)
|
|||
|
|
>>> torch.quantile(a, 0.4, interpolation='nearest')
|
|||
|
|
tensor(1.)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def quantize_per_channel(input: Tensor, scales: Tensor, zero_points: Tensor, axis: _int, dtype: _dtype) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
quantize_per_channel(input, scales, zero_points, axis, dtype) -> Tensor
|
|||
|
|
|
|||
|
|
Converts a float tensor to a per-channel quantized tensor with given scales and zero points.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
input (Tensor): float tensor to quantize
|
|||
|
|
scales (Tensor): float 1D tensor of scales to use, size should match ``input.size(axis)``
|
|||
|
|
zero_points (int): integer 1D tensor of offset to use, size should match ``input.size(axis)``
|
|||
|
|
axis (int): dimension on which apply per-channel quantization
|
|||
|
|
dtype (:class:`torch.dtype`): the desired data type of returned tensor.
|
|||
|
|
Has to be one of the quantized dtypes: ``torch.quint8``, ``torch.qint8``, ``torch.qint32``
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A newly quantized tensor
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.tensor([[-1.0, 0.0], [1.0, 2.0]])
|
|||
|
|
>>> torch.quantize_per_channel(x, torch.tensor([0.1, 0.01]), torch.tensor([10, 0]), 0, torch.quint8)
|
|||
|
|
tensor([[-1., 0.],
|
|||
|
|
[ 1., 2.]], size=(2, 2), dtype=torch.quint8,
|
|||
|
|
quantization_scheme=torch.per_channel_affine,
|
|||
|
|
scale=tensor([0.1000, 0.0100], dtype=torch.float64),
|
|||
|
|
zero_point=tensor([10, 0]), axis=0)
|
|||
|
|
>>> torch.quantize_per_channel(x, torch.tensor([0.1, 0.01]), torch.tensor([10, 0]), 0, torch.quint8).int_repr()
|
|||
|
|
tensor([[ 0, 10],
|
|||
|
|
[100, 200]], dtype=torch.uint8)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def quantize_per_tensor(input: Tensor, scale: Tensor, zero_point: Tensor, dtype: _dtype) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
quantize_per_tensor(input, scale, zero_point, dtype) -> Tensor
|
|||
|
|
|
|||
|
|
Converts a float tensor to a quantized tensor with given scale and zero point.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
input (Tensor): float tensor or list of tensors to quantize
|
|||
|
|
scale (float or Tensor): scale to apply in quantization formula
|
|||
|
|
zero_point (int or Tensor): offset in integer value that maps to float zero
|
|||
|
|
dtype (:class:`torch.dtype`): the desired data type of returned tensor.
|
|||
|
|
Has to be one of the quantized dtypes: ``torch.quint8``, ``torch.qint8``, ``torch.qint32``
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A newly quantized tensor or list of quantized tensors.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.quantize_per_tensor(torch.tensor([-1.0, 0.0, 1.0, 2.0]), 0.1, 10, torch.quint8)
|
|||
|
|
tensor([-1., 0., 1., 2.], size=(4,), dtype=torch.quint8,
|
|||
|
|
quantization_scheme=torch.per_tensor_affine, scale=0.1, zero_point=10)
|
|||
|
|
>>> torch.quantize_per_tensor(torch.tensor([-1.0, 0.0, 1.0, 2.0]), 0.1, 10, torch.quint8).int_repr()
|
|||
|
|
tensor([ 0, 10, 20, 30], dtype=torch.uint8)
|
|||
|
|
>>> torch.quantize_per_tensor([torch.tensor([-1.0, 0.0]), torch.tensor([-2.0, 2.0])],
|
|||
|
|
>>> torch.tensor([0.1, 0.2]), torch.tensor([10, 20]), torch.quint8)
|
|||
|
|
(tensor([-1., 0.], size=(2,), dtype=torch.quint8,
|
|||
|
|
quantization_scheme=torch.per_tensor_affine, scale=0.1, zero_point=10),
|
|||
|
|
tensor([-2., 2.], size=(2,), dtype=torch.quint8,
|
|||
|
|
quantization_scheme=torch.per_tensor_affine, scale=0.2, zero_point=20))
|
|||
|
|
>>> torch.quantize_per_tensor(torch.tensor([-1.0, 0.0, 1.0, 2.0]), torch.tensor(0.1), torch.tensor(10), torch.quint8)
|
|||
|
|
tensor([-1., 0., 1., 2.], size=(4,), dtype=torch.quint8,
|
|||
|
|
quantization_scheme=torch.per_tensor_affine, scale=0.10, zero_point=10)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def quantize_per_tensor(input: Tensor, scale: _float, zero_point: _int, dtype: _dtype) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
quantize_per_tensor(input, scale, zero_point, dtype) -> Tensor
|
|||
|
|
|
|||
|
|
Converts a float tensor to a quantized tensor with given scale and zero point.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
input (Tensor): float tensor or list of tensors to quantize
|
|||
|
|
scale (float or Tensor): scale to apply in quantization formula
|
|||
|
|
zero_point (int or Tensor): offset in integer value that maps to float zero
|
|||
|
|
dtype (:class:`torch.dtype`): the desired data type of returned tensor.
|
|||
|
|
Has to be one of the quantized dtypes: ``torch.quint8``, ``torch.qint8``, ``torch.qint32``
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A newly quantized tensor or list of quantized tensors.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.quantize_per_tensor(torch.tensor([-1.0, 0.0, 1.0, 2.0]), 0.1, 10, torch.quint8)
|
|||
|
|
tensor([-1., 0., 1., 2.], size=(4,), dtype=torch.quint8,
|
|||
|
|
quantization_scheme=torch.per_tensor_affine, scale=0.1, zero_point=10)
|
|||
|
|
>>> torch.quantize_per_tensor(torch.tensor([-1.0, 0.0, 1.0, 2.0]), 0.1, 10, torch.quint8).int_repr()
|
|||
|
|
tensor([ 0, 10, 20, 30], dtype=torch.uint8)
|
|||
|
|
>>> torch.quantize_per_tensor([torch.tensor([-1.0, 0.0]), torch.tensor([-2.0, 2.0])],
|
|||
|
|
>>> torch.tensor([0.1, 0.2]), torch.tensor([10, 20]), torch.quint8)
|
|||
|
|
(tensor([-1., 0.], size=(2,), dtype=torch.quint8,
|
|||
|
|
quantization_scheme=torch.per_tensor_affine, scale=0.1, zero_point=10),
|
|||
|
|
tensor([-2., 2.], size=(2,), dtype=torch.quint8,
|
|||
|
|
quantization_scheme=torch.per_tensor_affine, scale=0.2, zero_point=20))
|
|||
|
|
>>> torch.quantize_per_tensor(torch.tensor([-1.0, 0.0, 1.0, 2.0]), torch.tensor(0.1), torch.tensor(10), torch.quint8)
|
|||
|
|
tensor([-1., 0., 1., 2.], size=(4,), dtype=torch.quint8,
|
|||
|
|
quantization_scheme=torch.per_tensor_affine, scale=0.10, zero_point=10)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def quantize_per_tensor(tensors: Union[Tuple[Tensor, ...], List[Tensor]], scales: Tensor, zero_points: Tensor, dtype: _dtype) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
quantize_per_tensor(input, scale, zero_point, dtype) -> Tensor
|
|||
|
|
|
|||
|
|
Converts a float tensor to a quantized tensor with given scale and zero point.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
input (Tensor): float tensor or list of tensors to quantize
|
|||
|
|
scale (float or Tensor): scale to apply in quantization formula
|
|||
|
|
zero_point (int or Tensor): offset in integer value that maps to float zero
|
|||
|
|
dtype (:class:`torch.dtype`): the desired data type of returned tensor.
|
|||
|
|
Has to be one of the quantized dtypes: ``torch.quint8``, ``torch.qint8``, ``torch.qint32``
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A newly quantized tensor or list of quantized tensors.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.quantize_per_tensor(torch.tensor([-1.0, 0.0, 1.0, 2.0]), 0.1, 10, torch.quint8)
|
|||
|
|
tensor([-1., 0., 1., 2.], size=(4,), dtype=torch.quint8,
|
|||
|
|
quantization_scheme=torch.per_tensor_affine, scale=0.1, zero_point=10)
|
|||
|
|
>>> torch.quantize_per_tensor(torch.tensor([-1.0, 0.0, 1.0, 2.0]), 0.1, 10, torch.quint8).int_repr()
|
|||
|
|
tensor([ 0, 10, 20, 30], dtype=torch.uint8)
|
|||
|
|
>>> torch.quantize_per_tensor([torch.tensor([-1.0, 0.0]), torch.tensor([-2.0, 2.0])],
|
|||
|
|
>>> torch.tensor([0.1, 0.2]), torch.tensor([10, 20]), torch.quint8)
|
|||
|
|
(tensor([-1., 0.], size=(2,), dtype=torch.quint8,
|
|||
|
|
quantization_scheme=torch.per_tensor_affine, scale=0.1, zero_point=10),
|
|||
|
|
tensor([-2., 2.], size=(2,), dtype=torch.quint8,
|
|||
|
|
quantization_scheme=torch.per_tensor_affine, scale=0.2, zero_point=20))
|
|||
|
|
>>> torch.quantize_per_tensor(torch.tensor([-1.0, 0.0, 1.0, 2.0]), torch.tensor(0.1), torch.tensor(10), torch.quint8)
|
|||
|
|
tensor([-1., 0., 1., 2.], size=(4,), dtype=torch.quint8,
|
|||
|
|
quantization_scheme=torch.per_tensor_affine, scale=0.10, zero_point=10)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def quantize_per_tensor_dynamic(input: Tensor, dtype: _dtype, reduce_range: _bool) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
quantize_per_tensor_dynamic(input, dtype, reduce_range) -> Tensor
|
|||
|
|
|
|||
|
|
Converts a float tensor to a quantized tensor with scale and zero_point calculated
|
|||
|
|
dynamically based on the input.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
input (Tensor): float tensor or list of tensors to quantize
|
|||
|
|
dtype (:class:`torch.dtype`): the desired data type of returned tensor.
|
|||
|
|
Has to be one of the quantized dtypes: ``torch.quint8``, ``torch.qint8``
|
|||
|
|
reduce_range (bool): a flag to indicate whether to reduce the range of quantized
|
|||
|
|
data by 1 bit, it's required to avoid instruction overflow for some hardwares
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A newly (dynamically) quantized tensor
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> t = torch.quantize_per_tensor_dynamic(torch.tensor([-1.0, 0.0, 1.0, 2.0]), torch.quint8, False)
|
|||
|
|
>>> print(t)
|
|||
|
|
tensor([-1., 0., 1., 2.], size=(4,), dtype=torch.quint8,
|
|||
|
|
quantization_scheme=torch.per_tensor_affine, scale=0.011764705882352941,
|
|||
|
|
zero_point=85)
|
|||
|
|
>>> t.int_repr()
|
|||
|
|
tensor([ 0, 85, 170, 255], dtype=torch.uint8)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def quantized_batch_norm(input: Tensor, weight: Optional[Tensor], bias: Optional[Tensor], mean: Tensor, var: Tensor, eps: _float, output_scale: _float, output_zero_point: _int) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
quantized_batch_norm(input, weight=None, bias=None, mean, var, eps, output_scale, output_zero_point) -> Tensor
|
|||
|
|
|
|||
|
|
Applies batch normalization on a 4D (NCHW) quantized tensor.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
|
|||
|
|
y = \frac{x - \mathrm{E}[x]}{\sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
input (Tensor): quantized tensor
|
|||
|
|
weight (Tensor): float tensor that corresponds to the gamma, size C
|
|||
|
|
bias (Tensor): float tensor that corresponds to the beta, size C
|
|||
|
|
mean (Tensor): float mean value in batch normalization, size C
|
|||
|
|
var (Tensor): float tensor for variance, size C
|
|||
|
|
eps (float): a value added to the denominator for numerical stability.
|
|||
|
|
output_scale (float): output quantized tensor scale
|
|||
|
|
output_zero_point (int): output quantized tensor zero_point
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A quantized tensor with batch normalization applied.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> qx = torch.quantize_per_tensor(torch.rand(2, 2, 2, 2), 1.5, 3, torch.quint8)
|
|||
|
|
>>> torch.quantized_batch_norm(qx, torch.ones(2), torch.zeros(2), torch.rand(2), torch.rand(2), 0.00001, 0.2, 2)
|
|||
|
|
tensor([[[[-0.2000, -0.2000],
|
|||
|
|
[ 1.6000, -0.2000]],
|
|||
|
|
|
|||
|
|
[[-0.4000, -0.4000],
|
|||
|
|
[-0.4000, 0.6000]]],
|
|||
|
|
|
|||
|
|
|
|||
|
|
[[[-0.2000, -0.2000],
|
|||
|
|
[-0.2000, -0.2000]],
|
|||
|
|
|
|||
|
|
[[ 0.6000, -0.4000],
|
|||
|
|
[ 0.6000, -0.4000]]]], size=(2, 2, 2, 2), dtype=torch.quint8,
|
|||
|
|
quantization_scheme=torch.per_tensor_affine, scale=0.2, zero_point=2)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def quantized_gru_cell(input: Tensor, hx: Tensor, w_ih: Tensor, w_hh: Tensor, b_ih: Tensor, b_hh: Tensor, packed_ih: Tensor, packed_hh: Tensor, col_offsets_ih: Tensor, col_offsets_hh: Tensor, scale_ih: Union[Number, _complex], scale_hh: Union[Number, _complex], zero_point_ih: Union[Number, _complex], zero_point_hh: Union[Number, _complex]) -> Tensor: ...
|
|||
|
|
def quantized_lstm_cell(input: Tensor, hx: Union[Tuple[Tensor, ...], List[Tensor]], w_ih: Tensor, w_hh: Tensor, b_ih: Tensor, b_hh: Tensor, packed_ih: Tensor, packed_hh: Tensor, col_offsets_ih: Tensor, col_offsets_hh: Tensor, scale_ih: Union[Number, _complex], scale_hh: Union[Number, _complex], zero_point_ih: Union[Number, _complex], zero_point_hh: Union[Number, _complex]) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def quantized_max_pool1d(input: Tensor, kernel_size: Union[_int, _size], stride: Union[_int, _size] = (), padding: Union[_int, _size] = 0, dilation: Union[_int, _size] = 1, ceil_mode: _bool = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
quantized_max_pool1d(input, kernel_size, stride=[], padding=0, dilation=1, ceil_mode=False) -> Tensor
|
|||
|
|
|
|||
|
|
Applies a 1D max pooling over an input quantized tensor composed of several input planes.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
input (Tensor): quantized tensor
|
|||
|
|
kernel_size (list of int): the size of the sliding window
|
|||
|
|
stride (``list of int``, optional): the stride of the sliding window
|
|||
|
|
padding (``list of int``, optional): padding to be added on both sides, must be >= 0 and <= kernel_size / 2
|
|||
|
|
dilation (``list of int``, optional): The stride between elements within a sliding window, must be > 0. Default 1
|
|||
|
|
ceil_mode (bool, optional): If True, will use ceil instead of floor to compute the output shape.
|
|||
|
|
Defaults to False.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A quantized tensor with max_pool1d applied.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> qx = torch.quantize_per_tensor(torch.rand(2, 2), 1.5, 3, torch.quint8)
|
|||
|
|
>>> torch.quantized_max_pool1d(qx, [2])
|
|||
|
|
tensor([[0.0000],
|
|||
|
|
[1.5000]], size=(2, 1), dtype=torch.quint8,
|
|||
|
|
quantization_scheme=torch.per_tensor_affine, scale=1.5, zero_point=3)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def quantized_max_pool2d(input: Tensor, kernel_size: Union[_int, _size], stride: Union[_int, _size] = (), padding: Union[_int, _size] = 0, dilation: Union[_int, _size] = 1, ceil_mode: _bool = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
quantized_max_pool2d(input, kernel_size, stride=[], padding=0, dilation=1, ceil_mode=False) -> Tensor
|
|||
|
|
|
|||
|
|
Applies a 2D max pooling over an input quantized tensor composed of several input planes.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
input (Tensor): quantized tensor
|
|||
|
|
kernel_size (``list of int``): the size of the sliding window
|
|||
|
|
stride (``list of int``, optional): the stride of the sliding window
|
|||
|
|
padding (``list of int``, optional): padding to be added on both sides, must be >= 0 and <= kernel_size / 2
|
|||
|
|
dilation (``list of int``, optional): The stride between elements within a sliding window, must be > 0. Default 1
|
|||
|
|
ceil_mode (bool, optional): If True, will use ceil instead of floor to compute the output shape.
|
|||
|
|
Defaults to False.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A quantized tensor with max_pool2d applied.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> qx = torch.quantize_per_tensor(torch.rand(2, 2, 2, 2), 1.5, 3, torch.quint8)
|
|||
|
|
>>> torch.quantized_max_pool2d(qx, [2,2])
|
|||
|
|
tensor([[[[1.5000]],
|
|||
|
|
|
|||
|
|
[[1.5000]]],
|
|||
|
|
|
|||
|
|
|
|||
|
|
[[[0.0000]],
|
|||
|
|
|
|||
|
|
[[0.0000]]]], size=(2, 2, 1, 1), dtype=torch.quint8,
|
|||
|
|
quantization_scheme=torch.per_tensor_affine, scale=1.5, zero_point=3)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def quantized_max_pool3d(input: Tensor, kernel_size: Union[_int, _size], stride: Union[_int, _size] = (), padding: Union[_int, _size] = 0, dilation: Union[_int, _size] = 1, ceil_mode: _bool = False) -> Tensor: ...
|
|||
|
|
def quantized_rnn_relu_cell(input: Tensor, hx: Tensor, w_ih: Tensor, w_hh: Tensor, b_ih: Tensor, b_hh: Tensor, packed_ih: Tensor, packed_hh: Tensor, col_offsets_ih: Tensor, col_offsets_hh: Tensor, scale_ih: Union[Number, _complex], scale_hh: Union[Number, _complex], zero_point_ih: Union[Number, _complex], zero_point_hh: Union[Number, _complex]) -> Tensor: ...
|
|||
|
|
def quantized_rnn_tanh_cell(input: Tensor, hx: Tensor, w_ih: Tensor, w_hh: Tensor, b_ih: Tensor, b_hh: Tensor, packed_ih: Tensor, packed_hh: Tensor, col_offsets_ih: Tensor, col_offsets_hh: Tensor, scale_ih: Union[Number, _complex], scale_hh: Union[Number, _complex], zero_point_ih: Union[Number, _complex], zero_point_hh: Union[Number, _complex]) -> Tensor: ...
|
|||
|
|
def rad2deg(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
rad2deg(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with each of the elements of :attr:`input`
|
|||
|
|
converted from angles in radians to degrees.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([[3.142, -3.142], [6.283, -6.283], [1.570, -1.570]])
|
|||
|
|
>>> torch.rad2deg(a)
|
|||
|
|
tensor([[ 180.0233, -180.0233],
|
|||
|
|
[ 359.9894, -359.9894],
|
|||
|
|
[ 89.9544, -89.9544]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def rad2deg_(input: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def rand(size: Sequence[Union[_int, SymInt]], *, generator: Optional[Generator], names: Optional[Sequence[Union[str, ellipsis, None]]], dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
rand(*size, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with random numbers from a uniform distribution
|
|||
|
|
on the interval :math:`[0, 1)`
|
|||
|
|
|
|||
|
|
The shape of the tensor is defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.rand(4)
|
|||
|
|
tensor([ 0.5204, 0.2503, 0.3525, 0.5673])
|
|||
|
|
>>> torch.rand(2, 3)
|
|||
|
|
tensor([[ 0.8237, 0.5781, 0.6879],
|
|||
|
|
[ 0.3816, 0.7249, 0.0998]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def rand(*size: _int, generator: Optional[Generator], names: Optional[Sequence[Union[str, ellipsis, None]]], dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
rand(*size, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with random numbers from a uniform distribution
|
|||
|
|
on the interval :math:`[0, 1)`
|
|||
|
|
|
|||
|
|
The shape of the tensor is defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.rand(4)
|
|||
|
|
tensor([ 0.5204, 0.2503, 0.3525, 0.5673])
|
|||
|
|
>>> torch.rand(2, 3)
|
|||
|
|
tensor([[ 0.8237, 0.5781, 0.6879],
|
|||
|
|
[ 0.3816, 0.7249, 0.0998]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def rand(size: Sequence[Union[_int, SymInt]], *, generator: Optional[Generator], out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
rand(*size, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with random numbers from a uniform distribution
|
|||
|
|
on the interval :math:`[0, 1)`
|
|||
|
|
|
|||
|
|
The shape of the tensor is defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.rand(4)
|
|||
|
|
tensor([ 0.5204, 0.2503, 0.3525, 0.5673])
|
|||
|
|
>>> torch.rand(2, 3)
|
|||
|
|
tensor([[ 0.8237, 0.5781, 0.6879],
|
|||
|
|
[ 0.3816, 0.7249, 0.0998]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def rand(*size: _int, generator: Optional[Generator], out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
rand(*size, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with random numbers from a uniform distribution
|
|||
|
|
on the interval :math:`[0, 1)`
|
|||
|
|
|
|||
|
|
The shape of the tensor is defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.rand(4)
|
|||
|
|
tensor([ 0.5204, 0.2503, 0.3525, 0.5673])
|
|||
|
|
>>> torch.rand(2, 3)
|
|||
|
|
tensor([[ 0.8237, 0.5781, 0.6879],
|
|||
|
|
[ 0.3816, 0.7249, 0.0998]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def rand(size: Sequence[Union[_int, SymInt]], *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
rand(*size, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with random numbers from a uniform distribution
|
|||
|
|
on the interval :math:`[0, 1)`
|
|||
|
|
|
|||
|
|
The shape of the tensor is defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.rand(4)
|
|||
|
|
tensor([ 0.5204, 0.2503, 0.3525, 0.5673])
|
|||
|
|
>>> torch.rand(2, 3)
|
|||
|
|
tensor([[ 0.8237, 0.5781, 0.6879],
|
|||
|
|
[ 0.3816, 0.7249, 0.0998]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def rand(*size: _int, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
rand(*size, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with random numbers from a uniform distribution
|
|||
|
|
on the interval :math:`[0, 1)`
|
|||
|
|
|
|||
|
|
The shape of the tensor is defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.rand(4)
|
|||
|
|
tensor([ 0.5204, 0.2503, 0.3525, 0.5673])
|
|||
|
|
>>> torch.rand(2, 3)
|
|||
|
|
tensor([[ 0.8237, 0.5781, 0.6879],
|
|||
|
|
[ 0.3816, 0.7249, 0.0998]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def rand(size: Sequence[Union[_int, SymInt]], *, names: Optional[Sequence[Union[str, ellipsis, None]]], dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
rand(*size, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with random numbers from a uniform distribution
|
|||
|
|
on the interval :math:`[0, 1)`
|
|||
|
|
|
|||
|
|
The shape of the tensor is defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.rand(4)
|
|||
|
|
tensor([ 0.5204, 0.2503, 0.3525, 0.5673])
|
|||
|
|
>>> torch.rand(2, 3)
|
|||
|
|
tensor([[ 0.8237, 0.5781, 0.6879],
|
|||
|
|
[ 0.3816, 0.7249, 0.0998]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def rand(*size: _int, names: Optional[Sequence[Union[str, ellipsis, None]]], dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
rand(*size, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with random numbers from a uniform distribution
|
|||
|
|
on the interval :math:`[0, 1)`
|
|||
|
|
|
|||
|
|
The shape of the tensor is defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.rand(4)
|
|||
|
|
tensor([ 0.5204, 0.2503, 0.3525, 0.5673])
|
|||
|
|
>>> torch.rand(2, 3)
|
|||
|
|
tensor([[ 0.8237, 0.5781, 0.6879],
|
|||
|
|
[ 0.3816, 0.7249, 0.0998]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def rand_like(input: Tensor, *, memory_format: Optional[memory_format] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
rand_like(input, *, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor with the same size as :attr:`input` that is filled with
|
|||
|
|
random numbers from a uniform distribution on the interval :math:`[0, 1)`.
|
|||
|
|
``torch.rand_like(input)`` is equivalent to
|
|||
|
|
``torch.rand(input.size(), dtype=input.dtype, layout=input.layout, device=input.device)``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the size of :attr:`input` will determine size of the output tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned Tensor.
|
|||
|
|
Default: if ``None``, defaults to the dtype of :attr:`input`.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned tensor.
|
|||
|
|
Default: if ``None``, defaults to the layout of :attr:`input`.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, defaults to the device of :attr:`input`.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
memory_format (:class:`torch.memory_format`, optional): the desired memory format of
|
|||
|
|
returned Tensor. Default: ``torch.preserve_format``.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def randint(low: _int, high: _int, size: _size, *, generator: Optional[Generator] = None, dtype: Optional[_dtype] = None, device: Optional[DeviceLikeType] = None, requires_grad: _bool = False, pin_memory: _bool = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
randint(low=0, high, size, \*, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with random integers generated uniformly
|
|||
|
|
between :attr:`low` (inclusive) and :attr:`high` (exclusive).
|
|||
|
|
|
|||
|
|
The shape of the tensor is defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
With the global dtype default (``torch.float32``), this function returns
|
|||
|
|
a tensor with dtype ``torch.int64``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
low (int, optional): Lowest integer to be drawn from the distribution. Default: 0.
|
|||
|
|
high (int): One above the highest integer to be drawn from the distribution.
|
|||
|
|
size (tuple): a tuple defining the shape of the output tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (`torch.dtype`, optional) - the desired data type of returned tensor. Default: if ``None``,
|
|||
|
|
this function returns a tensor with dtype ``torch.int64``.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.randint(3, 5, (3,))
|
|||
|
|
tensor([4, 3, 4])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> torch.randint(10, (2, 2))
|
|||
|
|
tensor([[0, 2],
|
|||
|
|
[5, 5]])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> torch.randint(3, 10, (2, 2))
|
|||
|
|
tensor([[4, 5],
|
|||
|
|
[6, 7]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def randint(high: _int, size: _size, *, generator: Optional[Generator] = None, dtype: Optional[_dtype] = None, device: Optional[DeviceLikeType] = None, requires_grad: _bool = False, pin_memory: _bool = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
randint(low=0, high, size, \*, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with random integers generated uniformly
|
|||
|
|
between :attr:`low` (inclusive) and :attr:`high` (exclusive).
|
|||
|
|
|
|||
|
|
The shape of the tensor is defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
With the global dtype default (``torch.float32``), this function returns
|
|||
|
|
a tensor with dtype ``torch.int64``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
low (int, optional): Lowest integer to be drawn from the distribution. Default: 0.
|
|||
|
|
high (int): One above the highest integer to be drawn from the distribution.
|
|||
|
|
size (tuple): a tuple defining the shape of the output tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (`torch.dtype`, optional) - the desired data type of returned tensor. Default: if ``None``,
|
|||
|
|
this function returns a tensor with dtype ``torch.int64``.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.randint(3, 5, (3,))
|
|||
|
|
tensor([4, 3, 4])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> torch.randint(10, (2, 2))
|
|||
|
|
tensor([[0, 2],
|
|||
|
|
[5, 5]])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> torch.randint(3, 10, (2, 2))
|
|||
|
|
tensor([[4, 5],
|
|||
|
|
[6, 7]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def randint(high: Union[_int, SymInt], size: Sequence[Union[_int, SymInt]], *, generator: Optional[Generator], out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
randint(low=0, high, size, \*, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with random integers generated uniformly
|
|||
|
|
between :attr:`low` (inclusive) and :attr:`high` (exclusive).
|
|||
|
|
|
|||
|
|
The shape of the tensor is defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
With the global dtype default (``torch.float32``), this function returns
|
|||
|
|
a tensor with dtype ``torch.int64``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
low (int, optional): Lowest integer to be drawn from the distribution. Default: 0.
|
|||
|
|
high (int): One above the highest integer to be drawn from the distribution.
|
|||
|
|
size (tuple): a tuple defining the shape of the output tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (`torch.dtype`, optional) - the desired data type of returned tensor. Default: if ``None``,
|
|||
|
|
this function returns a tensor with dtype ``torch.int64``.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.randint(3, 5, (3,))
|
|||
|
|
tensor([4, 3, 4])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> torch.randint(10, (2, 2))
|
|||
|
|
tensor([[0, 2],
|
|||
|
|
[5, 5]])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> torch.randint(3, 10, (2, 2))
|
|||
|
|
tensor([[4, 5],
|
|||
|
|
[6, 7]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def randint(high: Union[_int, SymInt], size: Sequence[Union[_int, SymInt]], *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
randint(low=0, high, size, \*, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with random integers generated uniformly
|
|||
|
|
between :attr:`low` (inclusive) and :attr:`high` (exclusive).
|
|||
|
|
|
|||
|
|
The shape of the tensor is defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
With the global dtype default (``torch.float32``), this function returns
|
|||
|
|
a tensor with dtype ``torch.int64``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
low (int, optional): Lowest integer to be drawn from the distribution. Default: 0.
|
|||
|
|
high (int): One above the highest integer to be drawn from the distribution.
|
|||
|
|
size (tuple): a tuple defining the shape of the output tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (`torch.dtype`, optional) - the desired data type of returned tensor. Default: if ``None``,
|
|||
|
|
this function returns a tensor with dtype ``torch.int64``.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.randint(3, 5, (3,))
|
|||
|
|
tensor([4, 3, 4])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> torch.randint(10, (2, 2))
|
|||
|
|
tensor([[0, 2],
|
|||
|
|
[5, 5]])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> torch.randint(3, 10, (2, 2))
|
|||
|
|
tensor([[4, 5],
|
|||
|
|
[6, 7]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def randint(low: Union[_int, SymInt], high: Union[_int, SymInt], size: Sequence[Union[_int, SymInt]], *, generator: Optional[Generator], out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
randint(low=0, high, size, \*, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with random integers generated uniformly
|
|||
|
|
between :attr:`low` (inclusive) and :attr:`high` (exclusive).
|
|||
|
|
|
|||
|
|
The shape of the tensor is defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
With the global dtype default (``torch.float32``), this function returns
|
|||
|
|
a tensor with dtype ``torch.int64``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
low (int, optional): Lowest integer to be drawn from the distribution. Default: 0.
|
|||
|
|
high (int): One above the highest integer to be drawn from the distribution.
|
|||
|
|
size (tuple): a tuple defining the shape of the output tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (`torch.dtype`, optional) - the desired data type of returned tensor. Default: if ``None``,
|
|||
|
|
this function returns a tensor with dtype ``torch.int64``.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.randint(3, 5, (3,))
|
|||
|
|
tensor([4, 3, 4])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> torch.randint(10, (2, 2))
|
|||
|
|
tensor([[0, 2],
|
|||
|
|
[5, 5]])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> torch.randint(3, 10, (2, 2))
|
|||
|
|
tensor([[4, 5],
|
|||
|
|
[6, 7]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def randint(low: Union[_int, SymInt], high: Union[_int, SymInt], size: Sequence[Union[_int, SymInt]], *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
randint(low=0, high, size, \*, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with random integers generated uniformly
|
|||
|
|
between :attr:`low` (inclusive) and :attr:`high` (exclusive).
|
|||
|
|
|
|||
|
|
The shape of the tensor is defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
With the global dtype default (``torch.float32``), this function returns
|
|||
|
|
a tensor with dtype ``torch.int64``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
low (int, optional): Lowest integer to be drawn from the distribution. Default: 0.
|
|||
|
|
high (int): One above the highest integer to be drawn from the distribution.
|
|||
|
|
size (tuple): a tuple defining the shape of the output tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (`torch.dtype`, optional) - the desired data type of returned tensor. Default: if ``None``,
|
|||
|
|
this function returns a tensor with dtype ``torch.int64``.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.randint(3, 5, (3,))
|
|||
|
|
tensor([4, 3, 4])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> torch.randint(10, (2, 2))
|
|||
|
|
tensor([[0, 2],
|
|||
|
|
[5, 5]])
|
|||
|
|
|
|||
|
|
|
|||
|
|
>>> torch.randint(3, 10, (2, 2))
|
|||
|
|
tensor([[4, 5],
|
|||
|
|
[6, 7]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def randint_like(input: Tensor, high: Union[_int, SymInt], *, memory_format: Optional[memory_format] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
randint_like(input, low=0, high, \*, dtype=None, layout=torch.strided, device=None, requires_grad=False, memory_format=torch.preserve_format) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor with the same shape as Tensor :attr:`input` filled with
|
|||
|
|
random integers generated uniformly between :attr:`low` (inclusive) and
|
|||
|
|
:attr:`high` (exclusive).
|
|||
|
|
|
|||
|
|
.. note:
|
|||
|
|
With the global dtype default (``torch.float32``), this function returns
|
|||
|
|
a tensor with dtype ``torch.int64``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the size of :attr:`input` will determine size of the output tensor.
|
|||
|
|
low (int, optional): Lowest integer to be drawn from the distribution. Default: 0.
|
|||
|
|
high (int): One above the highest integer to be drawn from the distribution.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned Tensor.
|
|||
|
|
Default: if ``None``, defaults to the dtype of :attr:`input`.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned tensor.
|
|||
|
|
Default: if ``None``, defaults to the layout of :attr:`input`.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, defaults to the device of :attr:`input`.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
memory_format (:class:`torch.memory_format`, optional): the desired memory format of
|
|||
|
|
returned Tensor. Default: ``torch.preserve_format``.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def randint_like(input: Tensor, low: Union[_int, SymInt], high: Union[_int, SymInt], *, memory_format: Optional[memory_format] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
randint_like(input, low=0, high, \*, dtype=None, layout=torch.strided, device=None, requires_grad=False, memory_format=torch.preserve_format) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor with the same shape as Tensor :attr:`input` filled with
|
|||
|
|
random integers generated uniformly between :attr:`low` (inclusive) and
|
|||
|
|
:attr:`high` (exclusive).
|
|||
|
|
|
|||
|
|
.. note:
|
|||
|
|
With the global dtype default (``torch.float32``), this function returns
|
|||
|
|
a tensor with dtype ``torch.int64``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the size of :attr:`input` will determine size of the output tensor.
|
|||
|
|
low (int, optional): Lowest integer to be drawn from the distribution. Default: 0.
|
|||
|
|
high (int): One above the highest integer to be drawn from the distribution.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned Tensor.
|
|||
|
|
Default: if ``None``, defaults to the dtype of :attr:`input`.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned tensor.
|
|||
|
|
Default: if ``None``, defaults to the layout of :attr:`input`.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, defaults to the device of :attr:`input`.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
memory_format (:class:`torch.memory_format`, optional): the desired memory format of
|
|||
|
|
returned Tensor. Default: ``torch.preserve_format``.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def randn(size: Sequence[Union[_int, SymInt]], *, generator: Optional[Generator], names: Optional[Sequence[Union[str, ellipsis, None]]], dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
randn(*size, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False) -> Tensor
|
|||
|
|
|
|||
|
|
|
|||
|
|
Returns a tensor filled with random numbers from a normal distribution
|
|||
|
|
with mean `0` and variance `1` (also called the standard normal
|
|||
|
|
distribution).
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} \sim \mathcal{N}(0, 1)
|
|||
|
|
|
|||
|
|
For complex dtypes, the tensor is i.i.d. sampled from a `complex normal distribution`_ with zero mean and
|
|||
|
|
unit variance as
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} \sim \mathcal{CN}(0, 1)
|
|||
|
|
|
|||
|
|
This is equivalent to separately sampling the real :math:`(\operatorname{Re})` and imaginary
|
|||
|
|
:math:`(\operatorname{Im})` part of :math:`\text{out}_i` as
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\operatorname{Re}(\text{out}_{i}) \sim \mathcal{N}(0, \frac{1}{2}),\quad
|
|||
|
|
\operatorname{Im}(\text{out}_{i}) \sim \mathcal{N}(0, \frac{1}{2})
|
|||
|
|
|
|||
|
|
The shape of the tensor is defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.randn(4)
|
|||
|
|
tensor([-2.1436, 0.9966, 2.3426, -0.6366])
|
|||
|
|
>>> torch.randn(2, 3)
|
|||
|
|
tensor([[ 1.5954, 2.8929, -1.0923],
|
|||
|
|
[ 1.1719, -0.4709, -0.1996]])
|
|||
|
|
|
|||
|
|
.. _complex normal distribution: https://en.wikipedia.org/wiki/Complex_normal_distribution
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def randn(*size: _int, generator: Optional[Generator], names: Optional[Sequence[Union[str, ellipsis, None]]], dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
randn(*size, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False) -> Tensor
|
|||
|
|
|
|||
|
|
|
|||
|
|
Returns a tensor filled with random numbers from a normal distribution
|
|||
|
|
with mean `0` and variance `1` (also called the standard normal
|
|||
|
|
distribution).
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} \sim \mathcal{N}(0, 1)
|
|||
|
|
|
|||
|
|
For complex dtypes, the tensor is i.i.d. sampled from a `complex normal distribution`_ with zero mean and
|
|||
|
|
unit variance as
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} \sim \mathcal{CN}(0, 1)
|
|||
|
|
|
|||
|
|
This is equivalent to separately sampling the real :math:`(\operatorname{Re})` and imaginary
|
|||
|
|
:math:`(\operatorname{Im})` part of :math:`\text{out}_i` as
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\operatorname{Re}(\text{out}_{i}) \sim \mathcal{N}(0, \frac{1}{2}),\quad
|
|||
|
|
\operatorname{Im}(\text{out}_{i}) \sim \mathcal{N}(0, \frac{1}{2})
|
|||
|
|
|
|||
|
|
The shape of the tensor is defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.randn(4)
|
|||
|
|
tensor([-2.1436, 0.9966, 2.3426, -0.6366])
|
|||
|
|
>>> torch.randn(2, 3)
|
|||
|
|
tensor([[ 1.5954, 2.8929, -1.0923],
|
|||
|
|
[ 1.1719, -0.4709, -0.1996]])
|
|||
|
|
|
|||
|
|
.. _complex normal distribution: https://en.wikipedia.org/wiki/Complex_normal_distribution
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def randn(size: Sequence[Union[_int, SymInt]], *, generator: Optional[Generator], out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
randn(*size, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False) -> Tensor
|
|||
|
|
|
|||
|
|
|
|||
|
|
Returns a tensor filled with random numbers from a normal distribution
|
|||
|
|
with mean `0` and variance `1` (also called the standard normal
|
|||
|
|
distribution).
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} \sim \mathcal{N}(0, 1)
|
|||
|
|
|
|||
|
|
For complex dtypes, the tensor is i.i.d. sampled from a `complex normal distribution`_ with zero mean and
|
|||
|
|
unit variance as
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} \sim \mathcal{CN}(0, 1)
|
|||
|
|
|
|||
|
|
This is equivalent to separately sampling the real :math:`(\operatorname{Re})` and imaginary
|
|||
|
|
:math:`(\operatorname{Im})` part of :math:`\text{out}_i` as
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\operatorname{Re}(\text{out}_{i}) \sim \mathcal{N}(0, \frac{1}{2}),\quad
|
|||
|
|
\operatorname{Im}(\text{out}_{i}) \sim \mathcal{N}(0, \frac{1}{2})
|
|||
|
|
|
|||
|
|
The shape of the tensor is defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.randn(4)
|
|||
|
|
tensor([-2.1436, 0.9966, 2.3426, -0.6366])
|
|||
|
|
>>> torch.randn(2, 3)
|
|||
|
|
tensor([[ 1.5954, 2.8929, -1.0923],
|
|||
|
|
[ 1.1719, -0.4709, -0.1996]])
|
|||
|
|
|
|||
|
|
.. _complex normal distribution: https://en.wikipedia.org/wiki/Complex_normal_distribution
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def randn(*size: _int, generator: Optional[Generator], out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
randn(*size, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False) -> Tensor
|
|||
|
|
|
|||
|
|
|
|||
|
|
Returns a tensor filled with random numbers from a normal distribution
|
|||
|
|
with mean `0` and variance `1` (also called the standard normal
|
|||
|
|
distribution).
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} \sim \mathcal{N}(0, 1)
|
|||
|
|
|
|||
|
|
For complex dtypes, the tensor is i.i.d. sampled from a `complex normal distribution`_ with zero mean and
|
|||
|
|
unit variance as
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} \sim \mathcal{CN}(0, 1)
|
|||
|
|
|
|||
|
|
This is equivalent to separately sampling the real :math:`(\operatorname{Re})` and imaginary
|
|||
|
|
:math:`(\operatorname{Im})` part of :math:`\text{out}_i` as
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\operatorname{Re}(\text{out}_{i}) \sim \mathcal{N}(0, \frac{1}{2}),\quad
|
|||
|
|
\operatorname{Im}(\text{out}_{i}) \sim \mathcal{N}(0, \frac{1}{2})
|
|||
|
|
|
|||
|
|
The shape of the tensor is defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.randn(4)
|
|||
|
|
tensor([-2.1436, 0.9966, 2.3426, -0.6366])
|
|||
|
|
>>> torch.randn(2, 3)
|
|||
|
|
tensor([[ 1.5954, 2.8929, -1.0923],
|
|||
|
|
[ 1.1719, -0.4709, -0.1996]])
|
|||
|
|
|
|||
|
|
.. _complex normal distribution: https://en.wikipedia.org/wiki/Complex_normal_distribution
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def randn(size: Sequence[Union[_int, SymInt]], *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
randn(*size, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False) -> Tensor
|
|||
|
|
|
|||
|
|
|
|||
|
|
Returns a tensor filled with random numbers from a normal distribution
|
|||
|
|
with mean `0` and variance `1` (also called the standard normal
|
|||
|
|
distribution).
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} \sim \mathcal{N}(0, 1)
|
|||
|
|
|
|||
|
|
For complex dtypes, the tensor is i.i.d. sampled from a `complex normal distribution`_ with zero mean and
|
|||
|
|
unit variance as
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} \sim \mathcal{CN}(0, 1)
|
|||
|
|
|
|||
|
|
This is equivalent to separately sampling the real :math:`(\operatorname{Re})` and imaginary
|
|||
|
|
:math:`(\operatorname{Im})` part of :math:`\text{out}_i` as
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\operatorname{Re}(\text{out}_{i}) \sim \mathcal{N}(0, \frac{1}{2}),\quad
|
|||
|
|
\operatorname{Im}(\text{out}_{i}) \sim \mathcal{N}(0, \frac{1}{2})
|
|||
|
|
|
|||
|
|
The shape of the tensor is defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.randn(4)
|
|||
|
|
tensor([-2.1436, 0.9966, 2.3426, -0.6366])
|
|||
|
|
>>> torch.randn(2, 3)
|
|||
|
|
tensor([[ 1.5954, 2.8929, -1.0923],
|
|||
|
|
[ 1.1719, -0.4709, -0.1996]])
|
|||
|
|
|
|||
|
|
.. _complex normal distribution: https://en.wikipedia.org/wiki/Complex_normal_distribution
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def randn(*size: _int, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
randn(*size, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False) -> Tensor
|
|||
|
|
|
|||
|
|
|
|||
|
|
Returns a tensor filled with random numbers from a normal distribution
|
|||
|
|
with mean `0` and variance `1` (also called the standard normal
|
|||
|
|
distribution).
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} \sim \mathcal{N}(0, 1)
|
|||
|
|
|
|||
|
|
For complex dtypes, the tensor is i.i.d. sampled from a `complex normal distribution`_ with zero mean and
|
|||
|
|
unit variance as
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} \sim \mathcal{CN}(0, 1)
|
|||
|
|
|
|||
|
|
This is equivalent to separately sampling the real :math:`(\operatorname{Re})` and imaginary
|
|||
|
|
:math:`(\operatorname{Im})` part of :math:`\text{out}_i` as
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\operatorname{Re}(\text{out}_{i}) \sim \mathcal{N}(0, \frac{1}{2}),\quad
|
|||
|
|
\operatorname{Im}(\text{out}_{i}) \sim \mathcal{N}(0, \frac{1}{2})
|
|||
|
|
|
|||
|
|
The shape of the tensor is defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.randn(4)
|
|||
|
|
tensor([-2.1436, 0.9966, 2.3426, -0.6366])
|
|||
|
|
>>> torch.randn(2, 3)
|
|||
|
|
tensor([[ 1.5954, 2.8929, -1.0923],
|
|||
|
|
[ 1.1719, -0.4709, -0.1996]])
|
|||
|
|
|
|||
|
|
.. _complex normal distribution: https://en.wikipedia.org/wiki/Complex_normal_distribution
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def randn(size: Sequence[Union[_int, SymInt]], *, names: Optional[Sequence[Union[str, ellipsis, None]]], dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
randn(*size, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False) -> Tensor
|
|||
|
|
|
|||
|
|
|
|||
|
|
Returns a tensor filled with random numbers from a normal distribution
|
|||
|
|
with mean `0` and variance `1` (also called the standard normal
|
|||
|
|
distribution).
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} \sim \mathcal{N}(0, 1)
|
|||
|
|
|
|||
|
|
For complex dtypes, the tensor is i.i.d. sampled from a `complex normal distribution`_ with zero mean and
|
|||
|
|
unit variance as
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} \sim \mathcal{CN}(0, 1)
|
|||
|
|
|
|||
|
|
This is equivalent to separately sampling the real :math:`(\operatorname{Re})` and imaginary
|
|||
|
|
:math:`(\operatorname{Im})` part of :math:`\text{out}_i` as
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\operatorname{Re}(\text{out}_{i}) \sim \mathcal{N}(0, \frac{1}{2}),\quad
|
|||
|
|
\operatorname{Im}(\text{out}_{i}) \sim \mathcal{N}(0, \frac{1}{2})
|
|||
|
|
|
|||
|
|
The shape of the tensor is defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.randn(4)
|
|||
|
|
tensor([-2.1436, 0.9966, 2.3426, -0.6366])
|
|||
|
|
>>> torch.randn(2, 3)
|
|||
|
|
tensor([[ 1.5954, 2.8929, -1.0923],
|
|||
|
|
[ 1.1719, -0.4709, -0.1996]])
|
|||
|
|
|
|||
|
|
.. _complex normal distribution: https://en.wikipedia.org/wiki/Complex_normal_distribution
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def randn(*size: _int, names: Optional[Sequence[Union[str, ellipsis, None]]], dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
randn(*size, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False) -> Tensor
|
|||
|
|
|
|||
|
|
|
|||
|
|
Returns a tensor filled with random numbers from a normal distribution
|
|||
|
|
with mean `0` and variance `1` (also called the standard normal
|
|||
|
|
distribution).
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} \sim \mathcal{N}(0, 1)
|
|||
|
|
|
|||
|
|
For complex dtypes, the tensor is i.i.d. sampled from a `complex normal distribution`_ with zero mean and
|
|||
|
|
unit variance as
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} \sim \mathcal{CN}(0, 1)
|
|||
|
|
|
|||
|
|
This is equivalent to separately sampling the real :math:`(\operatorname{Re})` and imaginary
|
|||
|
|
:math:`(\operatorname{Im})` part of :math:`\text{out}_i` as
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\operatorname{Re}(\text{out}_{i}) \sim \mathcal{N}(0, \frac{1}{2}),\quad
|
|||
|
|
\operatorname{Im}(\text{out}_{i}) \sim \mathcal{N}(0, \frac{1}{2})
|
|||
|
|
|
|||
|
|
The shape of the tensor is defined by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.randn(4)
|
|||
|
|
tensor([-2.1436, 0.9966, 2.3426, -0.6366])
|
|||
|
|
>>> torch.randn(2, 3)
|
|||
|
|
tensor([[ 1.5954, 2.8929, -1.0923],
|
|||
|
|
[ 1.1719, -0.4709, -0.1996]])
|
|||
|
|
|
|||
|
|
.. _complex normal distribution: https://en.wikipedia.org/wiki/Complex_normal_distribution
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def randn_like(input: Tensor, *, memory_format: Optional[memory_format] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
randn_like(input, *, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor with the same size as :attr:`input` that is filled with
|
|||
|
|
random numbers from a normal distribution with mean 0 and variance 1. Please refer to :func:`torch.randn` for the
|
|||
|
|
sampling process of complex dtypes. ``torch.randn_like(input)`` is equivalent to
|
|||
|
|
``torch.randn(input.size(), dtype=input.dtype, layout=input.layout, device=input.device)``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the size of :attr:`input` will determine size of the output tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned Tensor.
|
|||
|
|
Default: if ``None``, defaults to the dtype of :attr:`input`.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned tensor.
|
|||
|
|
Default: if ``None``, defaults to the layout of :attr:`input`.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, defaults to the device of :attr:`input`.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
memory_format (:class:`torch.memory_format`, optional): the desired memory format of
|
|||
|
|
returned Tensor. Default: ``torch.preserve_format``.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def randperm(n: Union[_int, SymInt], *, generator: Optional[Generator], out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
randperm(n, *, generator=None, out=None, dtype=torch.int64,layout=torch.strided, device=None, requires_grad=False, pin_memory=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a random permutation of integers from ``0`` to ``n - 1``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
n (int): the upper bound (exclusive)
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: ``torch.int64``.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.randperm(4)
|
|||
|
|
tensor([2, 1, 0, 3])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def randperm(n: Union[_int, SymInt], *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
randperm(n, *, generator=None, out=None, dtype=torch.int64,layout=torch.strided, device=None, requires_grad=False, pin_memory=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a random permutation of integers from ``0`` to ``n - 1``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
n (int): the upper bound (exclusive)
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
generator (:class:`torch.Generator`, optional): a pseudorandom number generator for sampling
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: ``torch.int64``.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.randperm(4)
|
|||
|
|
tensor([2, 1, 0, 3])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def range(start: Number, end: Number, step: Number = 1, *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, device: Optional[DeviceLikeType] = None, requires_grad: _bool = False, pin_memory: _bool = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
range(start=0, end, step=1, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a 1-D tensor of size :math:`\left\lfloor \frac{\text{end} - \text{start}}{\text{step}} \right\rfloor + 1`
|
|||
|
|
with values from :attr:`start` to :attr:`end` with step :attr:`step`. Step is
|
|||
|
|
the gap between two values in the tensor.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i+1} = \text{out}_i + \text{step}.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
This function is deprecated and will be removed in a future release because its behavior is inconsistent with
|
|||
|
|
Python's range builtin. Instead, use :func:`torch.arange`, which produces values in [start, end).
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
start (float): the starting value for the set of points. Default: ``0``.
|
|||
|
|
end (float): the ending value for the set of points
|
|||
|
|
step (float): the gap between each pair of adjacent points. Default: ``1``.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`). If `dtype` is not given, infer the data type from the other input
|
|||
|
|
arguments. If any of `start`, `end`, or `stop` are floating-point, the
|
|||
|
|
`dtype` is inferred to be the default dtype, see
|
|||
|
|
:meth:`~torch.get_default_dtype`. Otherwise, the `dtype` is inferred to
|
|||
|
|
be `torch.int64`.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.range(1, 4)
|
|||
|
|
tensor([ 1., 2., 3., 4.])
|
|||
|
|
>>> torch.range(1, 4, 0.5)
|
|||
|
|
tensor([ 1.0000, 1.5000, 2.0000, 2.5000, 3.0000, 3.5000, 4.0000])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def ravel(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
ravel(input) -> Tensor
|
|||
|
|
|
|||
|
|
Return a contiguous flattened tensor. A copy is made only if needed.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> t = torch.tensor([[[1, 2],
|
|||
|
|
... [3, 4]],
|
|||
|
|
... [[5, 6],
|
|||
|
|
... [7, 8]]])
|
|||
|
|
>>> torch.ravel(t)
|
|||
|
|
tensor([1, 2, 3, 4, 5, 6, 7, 8])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def real(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
real(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor containing real values of the :attr:`self` tensor.
|
|||
|
|
The returned tensor and :attr:`self` share the same underlying storage.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x=torch.randn(4, dtype=torch.cfloat)
|
|||
|
|
>>> x
|
|||
|
|
tensor([(0.3100+0.3553j), (-0.5445-0.7896j), (-1.6492-0.0633j), (-0.0638-0.8119j)])
|
|||
|
|
>>> x.real
|
|||
|
|
tensor([ 0.3100, -0.5445, -1.6492, -0.0638])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def reciprocal(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
reciprocal(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the reciprocal of the elements of :attr:`input`
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \frac{1}{\text{input}_{i}}
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
Unlike NumPy's reciprocal, torch.reciprocal supports integral inputs. Integral
|
|||
|
|
inputs to reciprocal are automatically :ref:`promoted <type-promotion-doc>` to
|
|||
|
|
the default scalar type.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([-0.4595, -2.1219, -1.4314, 0.7298])
|
|||
|
|
>>> torch.reciprocal(a)
|
|||
|
|
tensor([-2.1763, -0.4713, -0.6986, 1.3702])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def reciprocal_(input: Tensor) -> Tensor: ...
|
|||
|
|
def relu(input: Tensor) -> Tensor: ...
|
|||
|
|
def relu_(input: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def remainder(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
remainder(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes
|
|||
|
|
`Python's modulus operation <https://docs.python.org/3/reference/expressions.html#binary-arithmetic-operations>`_
|
|||
|
|
entrywise. The result has the same sign as the divisor :attr:`other` and its absolute value
|
|||
|
|
is less than that of :attr:`other`.
|
|||
|
|
|
|||
|
|
It may also be defined in terms of :func:`torch.div` as
|
|||
|
|
|
|||
|
|
.. code:: python
|
|||
|
|
|
|||
|
|
torch.remainder(a, b) == a - a.div(b, rounding_mode="floor") * b
|
|||
|
|
|
|||
|
|
Supports :ref:`broadcasting to a common shape <broadcasting-semantics>`,
|
|||
|
|
:ref:`type promotion <type-promotion-doc>`, and integer and float inputs.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
Complex inputs are not supported. In some cases, it is not mathematically
|
|||
|
|
possible to satisfy the definition of a modulo operation with complex numbers.
|
|||
|
|
See :func:`torch.fmod` for how division by zero is handled.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.fmod` which implements C++'s `std::fmod <https://en.cppreference.com/w/cpp/numeric/math/fmod>`_.
|
|||
|
|
This one is defined in terms of division rounding towards zero.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor or Scalar): the dividend
|
|||
|
|
other (Tensor or Scalar): the divisor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.remainder(torch.tensor([-3., -2, -1, 1, 2, 3]), 2)
|
|||
|
|
tensor([ 1., 0., 1., 1., 0., 1.])
|
|||
|
|
>>> torch.remainder(torch.tensor([1, 2, 3, 4, 5]), -1.5)
|
|||
|
|
tensor([ -0.5000, -1.0000, 0.0000, -0.5000, -1.0000 ])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def remainder(self: Union[Number, _complex], other: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
remainder(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes
|
|||
|
|
`Python's modulus operation <https://docs.python.org/3/reference/expressions.html#binary-arithmetic-operations>`_
|
|||
|
|
entrywise. The result has the same sign as the divisor :attr:`other` and its absolute value
|
|||
|
|
is less than that of :attr:`other`.
|
|||
|
|
|
|||
|
|
It may also be defined in terms of :func:`torch.div` as
|
|||
|
|
|
|||
|
|
.. code:: python
|
|||
|
|
|
|||
|
|
torch.remainder(a, b) == a - a.div(b, rounding_mode="floor") * b
|
|||
|
|
|
|||
|
|
Supports :ref:`broadcasting to a common shape <broadcasting-semantics>`,
|
|||
|
|
:ref:`type promotion <type-promotion-doc>`, and integer and float inputs.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
Complex inputs are not supported. In some cases, it is not mathematically
|
|||
|
|
possible to satisfy the definition of a modulo operation with complex numbers.
|
|||
|
|
See :func:`torch.fmod` for how division by zero is handled.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.fmod` which implements C++'s `std::fmod <https://en.cppreference.com/w/cpp/numeric/math/fmod>`_.
|
|||
|
|
This one is defined in terms of division rounding towards zero.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor or Scalar): the dividend
|
|||
|
|
other (Tensor or Scalar): the divisor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.remainder(torch.tensor([-3., -2, -1, 1, 2, 3]), 2)
|
|||
|
|
tensor([ 1., 0., 1., 1., 0., 1.])
|
|||
|
|
>>> torch.remainder(torch.tensor([1, 2, 3, 4, 5]), -1.5)
|
|||
|
|
tensor([ -0.5000, -1.0000, 0.0000, -0.5000, -1.0000 ])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def remainder(input: Tensor, other: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
remainder(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes
|
|||
|
|
`Python's modulus operation <https://docs.python.org/3/reference/expressions.html#binary-arithmetic-operations>`_
|
|||
|
|
entrywise. The result has the same sign as the divisor :attr:`other` and its absolute value
|
|||
|
|
is less than that of :attr:`other`.
|
|||
|
|
|
|||
|
|
It may also be defined in terms of :func:`torch.div` as
|
|||
|
|
|
|||
|
|
.. code:: python
|
|||
|
|
|
|||
|
|
torch.remainder(a, b) == a - a.div(b, rounding_mode="floor") * b
|
|||
|
|
|
|||
|
|
Supports :ref:`broadcasting to a common shape <broadcasting-semantics>`,
|
|||
|
|
:ref:`type promotion <type-promotion-doc>`, and integer and float inputs.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
Complex inputs are not supported. In some cases, it is not mathematically
|
|||
|
|
possible to satisfy the definition of a modulo operation with complex numbers.
|
|||
|
|
See :func:`torch.fmod` for how division by zero is handled.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.fmod` which implements C++'s `std::fmod <https://en.cppreference.com/w/cpp/numeric/math/fmod>`_.
|
|||
|
|
This one is defined in terms of division rounding towards zero.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor or Scalar): the dividend
|
|||
|
|
other (Tensor or Scalar): the divisor
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.remainder(torch.tensor([-3., -2, -1, 1, 2, 3]), 2)
|
|||
|
|
tensor([ 1., 0., 1., 1., 0., 1.])
|
|||
|
|
>>> torch.remainder(torch.tensor([1, 2, 3, 4, 5]), -1.5)
|
|||
|
|
tensor([ -0.5000, -1.0000, 0.0000, -0.5000, -1.0000 ])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def renorm(input: Tensor, p: Union[Number, _complex], dim: _int, maxnorm: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
renorm(input, p, dim, maxnorm, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor where each sub-tensor of :attr:`input` along dimension
|
|||
|
|
:attr:`dim` is normalized such that the `p`-norm of the sub-tensor is lower
|
|||
|
|
than the value :attr:`maxnorm`
|
|||
|
|
|
|||
|
|
.. note:: If the norm of a row is lower than `maxnorm`, the row is unchanged
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
p (float): the power for the norm computation
|
|||
|
|
dim (int): the dimension to slice over to get the sub-tensors
|
|||
|
|
maxnorm (float): the maximum norm to keep each sub-tensor under
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.ones(3, 3)
|
|||
|
|
>>> x[1].fill_(2)
|
|||
|
|
tensor([ 2., 2., 2.])
|
|||
|
|
>>> x[2].fill_(3)
|
|||
|
|
tensor([ 3., 3., 3.])
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 1., 1., 1.],
|
|||
|
|
[ 2., 2., 2.],
|
|||
|
|
[ 3., 3., 3.]])
|
|||
|
|
>>> torch.renorm(x, 1, 0, 5)
|
|||
|
|
tensor([[ 1.0000, 1.0000, 1.0000],
|
|||
|
|
[ 1.6667, 1.6667, 1.6667],
|
|||
|
|
[ 1.6667, 1.6667, 1.6667]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def repeat_interleave(input: Tensor, repeats: Tensor, dim: Optional[_int] = None, *, output_size: Optional[Union[_int, SymInt]] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
repeat_interleave(input, repeats, dim=None, *, output_size=None) -> Tensor
|
|||
|
|
|
|||
|
|
Repeat elements of a tensor.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
|
|||
|
|
This is different from :meth:`torch.Tensor.repeat` but similar to ``numpy.repeat``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
repeats (Tensor or int): The number of repetitions for each element.
|
|||
|
|
repeats is broadcasted to fit the shape of the given axis.
|
|||
|
|
dim (int, optional): The dimension along which to repeat values.
|
|||
|
|
By default, use the flattened input array, and return a flat output
|
|||
|
|
array.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
output_size (int, optional): Total output size for the given axis
|
|||
|
|
( e.g. sum of repeats). If given, it will avoid stream synchronization
|
|||
|
|
needed to calculate output shape of the tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: Repeated tensor which has the same shape as input, except along the given axis.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.tensor([1, 2, 3])
|
|||
|
|
>>> x.repeat_interleave(2)
|
|||
|
|
tensor([1, 1, 2, 2, 3, 3])
|
|||
|
|
>>> y = torch.tensor([[1, 2], [3, 4]])
|
|||
|
|
>>> torch.repeat_interleave(y, 2)
|
|||
|
|
tensor([1, 1, 2, 2, 3, 3, 4, 4])
|
|||
|
|
>>> torch.repeat_interleave(y, 3, dim=1)
|
|||
|
|
tensor([[1, 1, 1, 2, 2, 2],
|
|||
|
|
[3, 3, 3, 4, 4, 4]])
|
|||
|
|
>>> torch.repeat_interleave(y, torch.tensor([1, 2]), dim=0)
|
|||
|
|
tensor([[1, 2],
|
|||
|
|
[3, 4],
|
|||
|
|
[3, 4]])
|
|||
|
|
>>> torch.repeat_interleave(y, torch.tensor([1, 2]), dim=0, output_size=3)
|
|||
|
|
tensor([[1, 2],
|
|||
|
|
[3, 4],
|
|||
|
|
[3, 4]])
|
|||
|
|
|
|||
|
|
If the `repeats` is `tensor([n1, n2, n3, ...])`, then the output will be
|
|||
|
|
`tensor([0, 0, ..., 1, 1, ..., 2, 2, ..., ...])` where `0` appears `n1` times,
|
|||
|
|
`1` appears `n2` times, `2` appears `n3` times, etc.
|
|||
|
|
|
|||
|
|
.. function:: repeat_interleave(repeats, *) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Repeats 0 repeats[0] times, 1 repeats[1] times, 2 repeats[2] times, etc.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
repeats (Tensor): The number of repetitions for each element.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: Repeated tensor of size `sum(repeats)`.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.repeat_interleave(torch.tensor([1, 2, 3]))
|
|||
|
|
tensor([0, 1, 1, 2, 2, 2])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def repeat_interleave(repeats: Tensor, *, output_size: Optional[Union[_int, SymInt]] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
repeat_interleave(input, repeats, dim=None, *, output_size=None) -> Tensor
|
|||
|
|
|
|||
|
|
Repeat elements of a tensor.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
|
|||
|
|
This is different from :meth:`torch.Tensor.repeat` but similar to ``numpy.repeat``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
repeats (Tensor or int): The number of repetitions for each element.
|
|||
|
|
repeats is broadcasted to fit the shape of the given axis.
|
|||
|
|
dim (int, optional): The dimension along which to repeat values.
|
|||
|
|
By default, use the flattened input array, and return a flat output
|
|||
|
|
array.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
output_size (int, optional): Total output size for the given axis
|
|||
|
|
( e.g. sum of repeats). If given, it will avoid stream synchronization
|
|||
|
|
needed to calculate output shape of the tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: Repeated tensor which has the same shape as input, except along the given axis.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.tensor([1, 2, 3])
|
|||
|
|
>>> x.repeat_interleave(2)
|
|||
|
|
tensor([1, 1, 2, 2, 3, 3])
|
|||
|
|
>>> y = torch.tensor([[1, 2], [3, 4]])
|
|||
|
|
>>> torch.repeat_interleave(y, 2)
|
|||
|
|
tensor([1, 1, 2, 2, 3, 3, 4, 4])
|
|||
|
|
>>> torch.repeat_interleave(y, 3, dim=1)
|
|||
|
|
tensor([[1, 1, 1, 2, 2, 2],
|
|||
|
|
[3, 3, 3, 4, 4, 4]])
|
|||
|
|
>>> torch.repeat_interleave(y, torch.tensor([1, 2]), dim=0)
|
|||
|
|
tensor([[1, 2],
|
|||
|
|
[3, 4],
|
|||
|
|
[3, 4]])
|
|||
|
|
>>> torch.repeat_interleave(y, torch.tensor([1, 2]), dim=0, output_size=3)
|
|||
|
|
tensor([[1, 2],
|
|||
|
|
[3, 4],
|
|||
|
|
[3, 4]])
|
|||
|
|
|
|||
|
|
If the `repeats` is `tensor([n1, n2, n3, ...])`, then the output will be
|
|||
|
|
`tensor([0, 0, ..., 1, 1, ..., 2, 2, ..., ...])` where `0` appears `n1` times,
|
|||
|
|
`1` appears `n2` times, `2` appears `n3` times, etc.
|
|||
|
|
|
|||
|
|
.. function:: repeat_interleave(repeats, *) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Repeats 0 repeats[0] times, 1 repeats[1] times, 2 repeats[2] times, etc.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
repeats (Tensor): The number of repetitions for each element.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: Repeated tensor of size `sum(repeats)`.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.repeat_interleave(torch.tensor([1, 2, 3]))
|
|||
|
|
tensor([0, 1, 1, 2, 2, 2])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def repeat_interleave(input: Tensor, repeats: Union[_int, SymInt], dim: Optional[_int] = None, *, output_size: Optional[Union[_int, SymInt]] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
repeat_interleave(input, repeats, dim=None, *, output_size=None) -> Tensor
|
|||
|
|
|
|||
|
|
Repeat elements of a tensor.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
|
|||
|
|
This is different from :meth:`torch.Tensor.repeat` but similar to ``numpy.repeat``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
repeats (Tensor or int): The number of repetitions for each element.
|
|||
|
|
repeats is broadcasted to fit the shape of the given axis.
|
|||
|
|
dim (int, optional): The dimension along which to repeat values.
|
|||
|
|
By default, use the flattened input array, and return a flat output
|
|||
|
|
array.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
output_size (int, optional): Total output size for the given axis
|
|||
|
|
( e.g. sum of repeats). If given, it will avoid stream synchronization
|
|||
|
|
needed to calculate output shape of the tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: Repeated tensor which has the same shape as input, except along the given axis.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.tensor([1, 2, 3])
|
|||
|
|
>>> x.repeat_interleave(2)
|
|||
|
|
tensor([1, 1, 2, 2, 3, 3])
|
|||
|
|
>>> y = torch.tensor([[1, 2], [3, 4]])
|
|||
|
|
>>> torch.repeat_interleave(y, 2)
|
|||
|
|
tensor([1, 1, 2, 2, 3, 3, 4, 4])
|
|||
|
|
>>> torch.repeat_interleave(y, 3, dim=1)
|
|||
|
|
tensor([[1, 1, 1, 2, 2, 2],
|
|||
|
|
[3, 3, 3, 4, 4, 4]])
|
|||
|
|
>>> torch.repeat_interleave(y, torch.tensor([1, 2]), dim=0)
|
|||
|
|
tensor([[1, 2],
|
|||
|
|
[3, 4],
|
|||
|
|
[3, 4]])
|
|||
|
|
>>> torch.repeat_interleave(y, torch.tensor([1, 2]), dim=0, output_size=3)
|
|||
|
|
tensor([[1, 2],
|
|||
|
|
[3, 4],
|
|||
|
|
[3, 4]])
|
|||
|
|
|
|||
|
|
If the `repeats` is `tensor([n1, n2, n3, ...])`, then the output will be
|
|||
|
|
`tensor([0, 0, ..., 1, 1, ..., 2, 2, ..., ...])` where `0` appears `n1` times,
|
|||
|
|
`1` appears `n2` times, `2` appears `n3` times, etc.
|
|||
|
|
|
|||
|
|
.. function:: repeat_interleave(repeats, *) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Repeats 0 repeats[0] times, 1 repeats[1] times, 2 repeats[2] times, etc.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
repeats (Tensor): The number of repetitions for each element.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: Repeated tensor of size `sum(repeats)`.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.repeat_interleave(torch.tensor([1, 2, 3]))
|
|||
|
|
tensor([0, 1, 1, 2, 2, 2])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def reshape(input: Tensor, shape: Sequence[Union[_int, SymInt]]) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
reshape(input, shape) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor with the same data and number of elements as :attr:`input`,
|
|||
|
|
but with the specified shape. When possible, the returned tensor will be a view
|
|||
|
|
of :attr:`input`. Otherwise, it will be a copy. Contiguous inputs and inputs
|
|||
|
|
with compatible strides can be reshaped without copying, but you should not
|
|||
|
|
depend on the copying vs. viewing behavior.
|
|||
|
|
|
|||
|
|
See :meth:`torch.Tensor.view` on when it is possible to return a view.
|
|||
|
|
|
|||
|
|
A single dimension may be -1, in which case it's inferred from the remaining
|
|||
|
|
dimensions and the number of elements in :attr:`input`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to be reshaped
|
|||
|
|
shape (tuple of int): the new shape
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.arange(4.)
|
|||
|
|
>>> torch.reshape(a, (2, 2))
|
|||
|
|
tensor([[ 0., 1.],
|
|||
|
|
[ 2., 3.]])
|
|||
|
|
>>> b = torch.tensor([[0, 1], [2, 3]])
|
|||
|
|
>>> torch.reshape(b, (-1,))
|
|||
|
|
tensor([ 0, 1, 2, 3])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def resize_as_(input: Tensor, the_template: Tensor, *, memory_format: Optional[memory_format] = None) -> Tensor: ...
|
|||
|
|
def resize_as_sparse_(input: Tensor, the_template: Tensor) -> Tensor: ...
|
|||
|
|
def resolve_conj(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
resolve_conj(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with materialized conjugation if :attr:`input`'s conjugate bit is set to `True`,
|
|||
|
|
else returns :attr:`input`. The output tensor will always have its conjugate bit set to `False`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.tensor([-1 + 1j, -2 + 2j, 3 - 3j])
|
|||
|
|
>>> y = x.conj()
|
|||
|
|
>>> y.is_conj()
|
|||
|
|
True
|
|||
|
|
>>> z = y.resolve_conj()
|
|||
|
|
>>> z
|
|||
|
|
tensor([-1 - 1j, -2 - 2j, 3 + 3j])
|
|||
|
|
>>> z.is_conj()
|
|||
|
|
False
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def resolve_neg(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
resolve_neg(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with materialized negation if :attr:`input`'s negative bit is set to `True`,
|
|||
|
|
else returns :attr:`input`. The output tensor will always have its negative bit set to `False`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.tensor([-1 + 1j, -2 + 2j, 3 - 3j])
|
|||
|
|
>>> y = x.conj()
|
|||
|
|
>>> z = y.imag
|
|||
|
|
>>> z.is_neg()
|
|||
|
|
True
|
|||
|
|
>>> out = z.resolve_neg()
|
|||
|
|
>>> out
|
|||
|
|
tensor([-1., -2., 3.])
|
|||
|
|
>>> out.is_neg()
|
|||
|
|
False
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def result_type(tensor: Tensor, other: Tensor) -> _dtype:
|
|||
|
|
r"""
|
|||
|
|
result_type(tensor1, tensor2) -> dtype
|
|||
|
|
|
|||
|
|
Returns the :class:`torch.dtype` that would result from performing an arithmetic
|
|||
|
|
operation on the provided input tensors. See type promotion :ref:`documentation <type-promotion-doc>`
|
|||
|
|
for more information on the type promotion logic.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
tensor1 (Tensor or Number): an input tensor or number
|
|||
|
|
tensor2 (Tensor or Number): an input tensor or number
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.result_type(torch.tensor([1, 2], dtype=torch.int), 1.0)
|
|||
|
|
torch.float32
|
|||
|
|
>>> torch.result_type(torch.tensor([1, 2], dtype=torch.uint8), torch.tensor(1))
|
|||
|
|
torch.uint8
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def result_type(scalar: Union[Number, _complex], tensor: Tensor) -> _dtype:
|
|||
|
|
r"""
|
|||
|
|
result_type(tensor1, tensor2) -> dtype
|
|||
|
|
|
|||
|
|
Returns the :class:`torch.dtype` that would result from performing an arithmetic
|
|||
|
|
operation on the provided input tensors. See type promotion :ref:`documentation <type-promotion-doc>`
|
|||
|
|
for more information on the type promotion logic.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
tensor1 (Tensor or Number): an input tensor or number
|
|||
|
|
tensor2 (Tensor or Number): an input tensor or number
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.result_type(torch.tensor([1, 2], dtype=torch.int), 1.0)
|
|||
|
|
torch.float32
|
|||
|
|
>>> torch.result_type(torch.tensor([1, 2], dtype=torch.uint8), torch.tensor(1))
|
|||
|
|
torch.uint8
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def result_type(tensor: Tensor, other: Union[Number, _complex]) -> _dtype:
|
|||
|
|
r"""
|
|||
|
|
result_type(tensor1, tensor2) -> dtype
|
|||
|
|
|
|||
|
|
Returns the :class:`torch.dtype` that would result from performing an arithmetic
|
|||
|
|
operation on the provided input tensors. See type promotion :ref:`documentation <type-promotion-doc>`
|
|||
|
|
for more information on the type promotion logic.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
tensor1 (Tensor or Number): an input tensor or number
|
|||
|
|
tensor2 (Tensor or Number): an input tensor or number
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.result_type(torch.tensor([1, 2], dtype=torch.int), 1.0)
|
|||
|
|
torch.float32
|
|||
|
|
>>> torch.result_type(torch.tensor([1, 2], dtype=torch.uint8), torch.tensor(1))
|
|||
|
|
torch.uint8
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def result_type(scalar1: Union[Number, _complex], scalar2: Union[Number, _complex]) -> _dtype:
|
|||
|
|
r"""
|
|||
|
|
result_type(tensor1, tensor2) -> dtype
|
|||
|
|
|
|||
|
|
Returns the :class:`torch.dtype` that would result from performing an arithmetic
|
|||
|
|
operation on the provided input tensors. See type promotion :ref:`documentation <type-promotion-doc>`
|
|||
|
|
for more information on the type promotion logic.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
tensor1 (Tensor or Number): an input tensor or number
|
|||
|
|
tensor2 (Tensor or Number): an input tensor or number
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.result_type(torch.tensor([1, 2], dtype=torch.int), 1.0)
|
|||
|
|
torch.float32
|
|||
|
|
>>> torch.result_type(torch.tensor([1, 2], dtype=torch.uint8), torch.tensor(1))
|
|||
|
|
torch.uint8
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def rnn_relu(data: Tensor, batch_sizes: Tensor, hx: Tensor, params: Union[Tuple[Tensor, ...], List[Tensor]], has_biases: _bool, num_layers: _int, dropout: _float, train: _bool, bidirectional: _bool) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
@overload
|
|||
|
|
def rnn_relu(input: Tensor, hx: Tensor, params: Union[Tuple[Tensor, ...], List[Tensor]], has_biases: _bool, num_layers: _int, dropout: _float, train: _bool, bidirectional: _bool, batch_first: _bool) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def rnn_relu_cell(input: Tensor, hx: Tensor, w_ih: Tensor, w_hh: Tensor, b_ih: Optional[Tensor] = None, b_hh: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def rnn_tanh(data: Tensor, batch_sizes: Tensor, hx: Tensor, params: Union[Tuple[Tensor, ...], List[Tensor]], has_biases: _bool, num_layers: _int, dropout: _float, train: _bool, bidirectional: _bool) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
@overload
|
|||
|
|
def rnn_tanh(input: Tensor, hx: Tensor, params: Union[Tuple[Tensor, ...], List[Tensor]], has_biases: _bool, num_layers: _int, dropout: _float, train: _bool, bidirectional: _bool, batch_first: _bool) -> Tuple[Tensor, Tensor]: ...
|
|||
|
|
def rnn_tanh_cell(input: Tensor, hx: Tensor, w_ih: Tensor, w_hh: Tensor, b_ih: Optional[Tensor] = None, b_hh: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def roll(input: Tensor, shifts: Union[Union[_int, SymInt], Sequence[Union[_int, SymInt]]], dims: Union[_int, _size] = ()) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
roll(input, shifts, dims=None) -> Tensor
|
|||
|
|
|
|||
|
|
Roll the tensor :attr:`input` along the given dimension(s). Elements that are
|
|||
|
|
shifted beyond the last position are re-introduced at the first position. If
|
|||
|
|
:attr:`dims` is `None`, the tensor will be flattened before rolling and then
|
|||
|
|
restored to the original shape.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
shifts (int or tuple of ints): The number of places by which the elements
|
|||
|
|
of the tensor are shifted. If shifts is a tuple, dims must be a tuple of
|
|||
|
|
the same size, and each dimension will be rolled by the corresponding
|
|||
|
|
value
|
|||
|
|
dims (int or tuple of ints): Axis along which to roll
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.tensor([1, 2, 3, 4, 5, 6, 7, 8]).view(4, 2)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[1, 2],
|
|||
|
|
[3, 4],
|
|||
|
|
[5, 6],
|
|||
|
|
[7, 8]])
|
|||
|
|
>>> torch.roll(x, 1)
|
|||
|
|
tensor([[8, 1],
|
|||
|
|
[2, 3],
|
|||
|
|
[4, 5],
|
|||
|
|
[6, 7]])
|
|||
|
|
>>> torch.roll(x, 1, 0)
|
|||
|
|
tensor([[7, 8],
|
|||
|
|
[1, 2],
|
|||
|
|
[3, 4],
|
|||
|
|
[5, 6]])
|
|||
|
|
>>> torch.roll(x, -1, 0)
|
|||
|
|
tensor([[3, 4],
|
|||
|
|
[5, 6],
|
|||
|
|
[7, 8],
|
|||
|
|
[1, 2]])
|
|||
|
|
>>> torch.roll(x, shifts=(2, 1), dims=(0, 1))
|
|||
|
|
tensor([[6, 5],
|
|||
|
|
[8, 7],
|
|||
|
|
[2, 1],
|
|||
|
|
[4, 3]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def rot90(input: Tensor, k: _int = 1, dims: _size = (0,1)) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
rot90(input, k=1, dims=[0,1]) -> Tensor
|
|||
|
|
|
|||
|
|
Rotate an n-D tensor by 90 degrees in the plane specified by dims axis.
|
|||
|
|
Rotation direction is from the first towards the second axis if k > 0, and from the second towards the first for k < 0.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
k (int): number of times to rotate. Default value is 1
|
|||
|
|
dims (a list or tuple): axis to rotate. Default value is [0, 1]
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.arange(4).view(2, 2)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[0, 1],
|
|||
|
|
[2, 3]])
|
|||
|
|
>>> torch.rot90(x, 1, [0, 1])
|
|||
|
|
tensor([[1, 3],
|
|||
|
|
[0, 2]])
|
|||
|
|
|
|||
|
|
>>> x = torch.arange(8).view(2, 2, 2)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[[0, 1],
|
|||
|
|
[2, 3]],
|
|||
|
|
|
|||
|
|
[[4, 5],
|
|||
|
|
[6, 7]]])
|
|||
|
|
>>> torch.rot90(x, 1, [1, 2])
|
|||
|
|
tensor([[[1, 3],
|
|||
|
|
[0, 2]],
|
|||
|
|
|
|||
|
|
[[5, 7],
|
|||
|
|
[4, 6]]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def round(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
round(input, *, decimals=0, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Rounds elements of :attr:`input` to the nearest integer.
|
|||
|
|
|
|||
|
|
For integer inputs, follows the array-api convention of returning a
|
|||
|
|
copy of the input tensor.
|
|||
|
|
The return type of output is same as that of input's dtype.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
This function implements the "round half to even" to
|
|||
|
|
break ties when a number is equidistant from two
|
|||
|
|
integers (e.g. `round(2.5)` is 2).
|
|||
|
|
|
|||
|
|
When the :attr:\`decimals\` argument is specified the
|
|||
|
|
algorithm used is similar to NumPy's `around`. This
|
|||
|
|
algorithm is fast but inexact and it can easily
|
|||
|
|
overflow for low precision dtypes.
|
|||
|
|
Eg. `round(tensor([10000], dtype=torch.float16), decimals=3)` is `inf`.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
:func:`torch.ceil`, which rounds up.
|
|||
|
|
:func:`torch.floor`, which rounds down.
|
|||
|
|
:func:`torch.trunc`, which rounds towards zero.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
decimals (int): Number of decimal places to round to (default: 0).
|
|||
|
|
If decimals is negative, it specifies the number of positions
|
|||
|
|
to the left of the decimal point.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.round(torch.tensor((4.7, -2.3, 9.1, -7.7)))
|
|||
|
|
tensor([ 5., -2., 9., -8.])
|
|||
|
|
|
|||
|
|
>>> # Values equidistant from two integers are rounded towards the
|
|||
|
|
>>> # the nearest even value (zero is treated as even)
|
|||
|
|
>>> torch.round(torch.tensor([-0.5, 0.5, 1.5, 2.5]))
|
|||
|
|
tensor([-0., 0., 2., 2.])
|
|||
|
|
|
|||
|
|
>>> # A positive decimals argument rounds to the to that decimal place
|
|||
|
|
>>> torch.round(torch.tensor([0.1234567]), decimals=3)
|
|||
|
|
tensor([0.1230])
|
|||
|
|
|
|||
|
|
>>> # A negative decimals argument rounds to the left of the decimal
|
|||
|
|
>>> torch.round(torch.tensor([1200.1234567]), decimals=-3)
|
|||
|
|
tensor([1000.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def round(input: Tensor, *, decimals: _int, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
round(input, *, decimals=0, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Rounds elements of :attr:`input` to the nearest integer.
|
|||
|
|
|
|||
|
|
For integer inputs, follows the array-api convention of returning a
|
|||
|
|
copy of the input tensor.
|
|||
|
|
The return type of output is same as that of input's dtype.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
This function implements the "round half to even" to
|
|||
|
|
break ties when a number is equidistant from two
|
|||
|
|
integers (e.g. `round(2.5)` is 2).
|
|||
|
|
|
|||
|
|
When the :attr:\`decimals\` argument is specified the
|
|||
|
|
algorithm used is similar to NumPy's `around`. This
|
|||
|
|
algorithm is fast but inexact and it can easily
|
|||
|
|
overflow for low precision dtypes.
|
|||
|
|
Eg. `round(tensor([10000], dtype=torch.float16), decimals=3)` is `inf`.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
:func:`torch.ceil`, which rounds up.
|
|||
|
|
:func:`torch.floor`, which rounds down.
|
|||
|
|
:func:`torch.trunc`, which rounds towards zero.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
decimals (int): Number of decimal places to round to (default: 0).
|
|||
|
|
If decimals is negative, it specifies the number of positions
|
|||
|
|
to the left of the decimal point.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.round(torch.tensor((4.7, -2.3, 9.1, -7.7)))
|
|||
|
|
tensor([ 5., -2., 9., -8.])
|
|||
|
|
|
|||
|
|
>>> # Values equidistant from two integers are rounded towards the
|
|||
|
|
>>> # the nearest even value (zero is treated as even)
|
|||
|
|
>>> torch.round(torch.tensor([-0.5, 0.5, 1.5, 2.5]))
|
|||
|
|
tensor([-0., 0., 2., 2.])
|
|||
|
|
|
|||
|
|
>>> # A positive decimals argument rounds to the to that decimal place
|
|||
|
|
>>> torch.round(torch.tensor([0.1234567]), decimals=3)
|
|||
|
|
tensor([0.1230])
|
|||
|
|
|
|||
|
|
>>> # A negative decimals argument rounds to the left of the decimal
|
|||
|
|
>>> torch.round(torch.tensor([1200.1234567]), decimals=-3)
|
|||
|
|
tensor([1000.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def round_(input: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def round_(input: Tensor, *, decimals: _int) -> Tensor: ...
|
|||
|
|
def row_indices_copy(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def row_stack(tensors: Union[Tuple[Tensor, ...], List[Tensor]], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
row_stack(tensors, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias of :func:`torch.vstack`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def rrelu(input: Tensor, lower: Union[Number, _complex] = 0.125, upper: Union[Number, _complex] = 0.3333333333333333, training: _bool = False, generator: Optional[Generator] = None) -> Tensor: ...
|
|||
|
|
def rrelu_(input: Tensor, lower: Union[Number, _complex] = 0.125, upper: Union[Number, _complex] = 0.3333333333333333, training: _bool = False, generator: Optional[Generator] = None) -> Tensor: ...
|
|||
|
|
def rsqrt(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
rsqrt(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the reciprocal of the square-root of each of
|
|||
|
|
the elements of :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \frac{1}{\sqrt{\text{input}_{i}}}
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([-0.0370, 0.2970, 1.5420, -0.9105])
|
|||
|
|
>>> torch.rsqrt(a)
|
|||
|
|
tensor([ nan, 1.8351, 0.8053, nan])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def rsqrt_(input: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def rsub(input: Tensor, other: Tensor, *, alpha: Union[Number, _complex] = 1) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def rsub(input: Tensor, other: Union[Number, _complex], alpha: Union[Number, _complex] = 1) -> Tensor: ...
|
|||
|
|
def saddmm(input: Tensor, mat1: Tensor, mat2: Tensor, *, beta: Number = 1, alpha: Number = 1, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def scalar_tensor(s: Union[Number, _complex], *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def scatter(input: Tensor, dim: _int, index: Tensor, src: Tensor, *, reduce: str, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
scatter(input, dim, index, src) -> Tensor
|
|||
|
|
|
|||
|
|
Out-of-place version of :meth:`torch.Tensor.scatter_`
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def scatter(input: Tensor, dim: _int, index: Tensor, src: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
scatter(input, dim, index, src) -> Tensor
|
|||
|
|
|
|||
|
|
Out-of-place version of :meth:`torch.Tensor.scatter_`
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def scatter(input: Tensor, dim: _int, index: Tensor, value: Union[Number, _complex], *, reduce: str, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
scatter(input, dim, index, src) -> Tensor
|
|||
|
|
|
|||
|
|
Out-of-place version of :meth:`torch.Tensor.scatter_`
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def scatter(input: Tensor, dim: Union[str, ellipsis, None], index: Tensor, src: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
scatter(input, dim, index, src) -> Tensor
|
|||
|
|
|
|||
|
|
Out-of-place version of :meth:`torch.Tensor.scatter_`
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def scatter(input: Tensor, dim: _int, index: Tensor, value: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
scatter(input, dim, index, src) -> Tensor
|
|||
|
|
|
|||
|
|
Out-of-place version of :meth:`torch.Tensor.scatter_`
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def scatter(input: Tensor, dim: Union[str, ellipsis, None], index: Tensor, value: Union[Number, _complex]) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
scatter(input, dim, index, src) -> Tensor
|
|||
|
|
|
|||
|
|
Out-of-place version of :meth:`torch.Tensor.scatter_`
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def scatter_add(input: Tensor, dim: _int, index: Tensor, src: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
scatter_add(input, dim, index, src) -> Tensor
|
|||
|
|
|
|||
|
|
Out-of-place version of :meth:`torch.Tensor.scatter_add_`
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def scatter_add(input: Tensor, dim: Union[str, ellipsis, None], index: Tensor, src: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
scatter_add(input, dim, index, src) -> Tensor
|
|||
|
|
|
|||
|
|
Out-of-place version of :meth:`torch.Tensor.scatter_add_`
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def scatter_reduce(input: Tensor, dim: _int, index: Tensor, src: Tensor, reduce: str, *, include_self: _bool = True, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
scatter_reduce(input, dim, index, src, reduce, *, include_self=True) -> Tensor
|
|||
|
|
|
|||
|
|
Out-of-place version of :meth:`torch.Tensor.scatter_reduce_`
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def searchsorted(sorted_sequence: Tensor, input: Tensor, *, out_int32: _bool = False, right: _bool = False, side: Optional[str] = None, sorter: Optional[Tensor] = None, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
searchsorted(sorted_sequence, values, *, out_int32=False, right=False, side=None, out=None, sorter=None) -> Tensor
|
|||
|
|
|
|||
|
|
Find the indices from the *innermost* dimension of :attr:`sorted_sequence` such that, if the
|
|||
|
|
corresponding values in :attr:`values` were inserted before the indices, when sorted, the order
|
|||
|
|
of the corresponding *innermost* dimension within :attr:`sorted_sequence` would be preserved.
|
|||
|
|
Return a new tensor with the same size as :attr:`values`. More formally,
|
|||
|
|
the returned index satisfies the following rules:
|
|||
|
|
|
|||
|
|
.. list-table::
|
|||
|
|
:widths: 12 10 78
|
|||
|
|
:header-rows: 1
|
|||
|
|
|
|||
|
|
* - :attr:`sorted_sequence`
|
|||
|
|
- :attr:`right`
|
|||
|
|
- *returned index satisfies*
|
|||
|
|
* - 1-D
|
|||
|
|
- False
|
|||
|
|
- ``sorted_sequence[i-1] < values[m][n]...[l][x] <= sorted_sequence[i]``
|
|||
|
|
* - 1-D
|
|||
|
|
- True
|
|||
|
|
- ``sorted_sequence[i-1] <= values[m][n]...[l][x] < sorted_sequence[i]``
|
|||
|
|
* - N-D
|
|||
|
|
- False
|
|||
|
|
- ``sorted_sequence[m][n]...[l][i-1] < values[m][n]...[l][x] <= sorted_sequence[m][n]...[l][i]``
|
|||
|
|
* - N-D
|
|||
|
|
- True
|
|||
|
|
- ``sorted_sequence[m][n]...[l][i-1] <= values[m][n]...[l][x] < sorted_sequence[m][n]...[l][i]``
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
sorted_sequence (Tensor): N-D or 1-D tensor, containing monotonically increasing sequence on the *innermost*
|
|||
|
|
dimension unless :attr:`sorter` is provided, in which case the sequence does not
|
|||
|
|
need to be sorted
|
|||
|
|
values (Tensor or Scalar): N-D tensor or a Scalar containing the search value(s).
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out_int32 (bool, optional): indicate the output data type. torch.int32 if True, torch.int64 otherwise.
|
|||
|
|
Default value is False, i.e. default output data type is torch.int64.
|
|||
|
|
right (bool, optional): if False, return the first suitable location that is found. If True, return the
|
|||
|
|
last such index. If no suitable index found, return 0 for non-numerical value
|
|||
|
|
(eg. nan, inf) or the size of *innermost* dimension within :attr:`sorted_sequence`
|
|||
|
|
(one pass the last index of the *innermost* dimension). In other words, if False,
|
|||
|
|
gets the lower bound index for each value in :attr:`values` on the corresponding
|
|||
|
|
*innermost* dimension of the :attr:`sorted_sequence`. If True, gets the upper
|
|||
|
|
bound index instead. Default value is False. :attr:`side` does the same and is
|
|||
|
|
preferred. It will error if :attr:`side` is set to "left" while this is True.
|
|||
|
|
side (str, optional): the same as :attr:`right` but preferred. "left" corresponds to False for :attr:`right`
|
|||
|
|
and "right" corresponds to True for :attr:`right`. It will error if this is set to
|
|||
|
|
"left" while :attr:`right` is True. Default value is None.
|
|||
|
|
out (Tensor, optional): the output tensor, must be the same size as :attr:`values` if provided.
|
|||
|
|
sorter (LongTensor, optional): if provided, a tensor matching the shape of the unsorted
|
|||
|
|
:attr:`sorted_sequence` containing a sequence of indices that sort it in the
|
|||
|
|
ascending order on the innermost dimension
|
|||
|
|
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> sorted_sequence = torch.tensor([[1, 3, 5, 7, 9], [2, 4, 6, 8, 10]])
|
|||
|
|
>>> sorted_sequence
|
|||
|
|
tensor([[ 1, 3, 5, 7, 9],
|
|||
|
|
[ 2, 4, 6, 8, 10]])
|
|||
|
|
>>> values = torch.tensor([[3, 6, 9], [3, 6, 9]])
|
|||
|
|
>>> values
|
|||
|
|
tensor([[3, 6, 9],
|
|||
|
|
[3, 6, 9]])
|
|||
|
|
>>> torch.searchsorted(sorted_sequence, values)
|
|||
|
|
tensor([[1, 3, 4],
|
|||
|
|
[1, 2, 4]])
|
|||
|
|
>>> torch.searchsorted(sorted_sequence, values, side='right')
|
|||
|
|
tensor([[2, 3, 5],
|
|||
|
|
[1, 3, 4]])
|
|||
|
|
|
|||
|
|
>>> sorted_sequence_1d = torch.tensor([1, 3, 5, 7, 9])
|
|||
|
|
>>> sorted_sequence_1d
|
|||
|
|
tensor([1, 3, 5, 7, 9])
|
|||
|
|
>>> torch.searchsorted(sorted_sequence_1d, values)
|
|||
|
|
tensor([[1, 3, 4],
|
|||
|
|
[1, 3, 4]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def searchsorted(sorted_sequence: Tensor, self: Union[Number, _complex], *, out_int32: _bool = False, right: _bool = False, side: Optional[str] = None, sorter: Optional[Tensor] = None, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
searchsorted(sorted_sequence, values, *, out_int32=False, right=False, side=None, out=None, sorter=None) -> Tensor
|
|||
|
|
|
|||
|
|
Find the indices from the *innermost* dimension of :attr:`sorted_sequence` such that, if the
|
|||
|
|
corresponding values in :attr:`values` were inserted before the indices, when sorted, the order
|
|||
|
|
of the corresponding *innermost* dimension within :attr:`sorted_sequence` would be preserved.
|
|||
|
|
Return a new tensor with the same size as :attr:`values`. More formally,
|
|||
|
|
the returned index satisfies the following rules:
|
|||
|
|
|
|||
|
|
.. list-table::
|
|||
|
|
:widths: 12 10 78
|
|||
|
|
:header-rows: 1
|
|||
|
|
|
|||
|
|
* - :attr:`sorted_sequence`
|
|||
|
|
- :attr:`right`
|
|||
|
|
- *returned index satisfies*
|
|||
|
|
* - 1-D
|
|||
|
|
- False
|
|||
|
|
- ``sorted_sequence[i-1] < values[m][n]...[l][x] <= sorted_sequence[i]``
|
|||
|
|
* - 1-D
|
|||
|
|
- True
|
|||
|
|
- ``sorted_sequence[i-1] <= values[m][n]...[l][x] < sorted_sequence[i]``
|
|||
|
|
* - N-D
|
|||
|
|
- False
|
|||
|
|
- ``sorted_sequence[m][n]...[l][i-1] < values[m][n]...[l][x] <= sorted_sequence[m][n]...[l][i]``
|
|||
|
|
* - N-D
|
|||
|
|
- True
|
|||
|
|
- ``sorted_sequence[m][n]...[l][i-1] <= values[m][n]...[l][x] < sorted_sequence[m][n]...[l][i]``
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
sorted_sequence (Tensor): N-D or 1-D tensor, containing monotonically increasing sequence on the *innermost*
|
|||
|
|
dimension unless :attr:`sorter` is provided, in which case the sequence does not
|
|||
|
|
need to be sorted
|
|||
|
|
values (Tensor or Scalar): N-D tensor or a Scalar containing the search value(s).
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out_int32 (bool, optional): indicate the output data type. torch.int32 if True, torch.int64 otherwise.
|
|||
|
|
Default value is False, i.e. default output data type is torch.int64.
|
|||
|
|
right (bool, optional): if False, return the first suitable location that is found. If True, return the
|
|||
|
|
last such index. If no suitable index found, return 0 for non-numerical value
|
|||
|
|
(eg. nan, inf) or the size of *innermost* dimension within :attr:`sorted_sequence`
|
|||
|
|
(one pass the last index of the *innermost* dimension). In other words, if False,
|
|||
|
|
gets the lower bound index for each value in :attr:`values` on the corresponding
|
|||
|
|
*innermost* dimension of the :attr:`sorted_sequence`. If True, gets the upper
|
|||
|
|
bound index instead. Default value is False. :attr:`side` does the same and is
|
|||
|
|
preferred. It will error if :attr:`side` is set to "left" while this is True.
|
|||
|
|
side (str, optional): the same as :attr:`right` but preferred. "left" corresponds to False for :attr:`right`
|
|||
|
|
and "right" corresponds to True for :attr:`right`. It will error if this is set to
|
|||
|
|
"left" while :attr:`right` is True. Default value is None.
|
|||
|
|
out (Tensor, optional): the output tensor, must be the same size as :attr:`values` if provided.
|
|||
|
|
sorter (LongTensor, optional): if provided, a tensor matching the shape of the unsorted
|
|||
|
|
:attr:`sorted_sequence` containing a sequence of indices that sort it in the
|
|||
|
|
ascending order on the innermost dimension
|
|||
|
|
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> sorted_sequence = torch.tensor([[1, 3, 5, 7, 9], [2, 4, 6, 8, 10]])
|
|||
|
|
>>> sorted_sequence
|
|||
|
|
tensor([[ 1, 3, 5, 7, 9],
|
|||
|
|
[ 2, 4, 6, 8, 10]])
|
|||
|
|
>>> values = torch.tensor([[3, 6, 9], [3, 6, 9]])
|
|||
|
|
>>> values
|
|||
|
|
tensor([[3, 6, 9],
|
|||
|
|
[3, 6, 9]])
|
|||
|
|
>>> torch.searchsorted(sorted_sequence, values)
|
|||
|
|
tensor([[1, 3, 4],
|
|||
|
|
[1, 2, 4]])
|
|||
|
|
>>> torch.searchsorted(sorted_sequence, values, side='right')
|
|||
|
|
tensor([[2, 3, 5],
|
|||
|
|
[1, 3, 4]])
|
|||
|
|
|
|||
|
|
>>> sorted_sequence_1d = torch.tensor([1, 3, 5, 7, 9])
|
|||
|
|
>>> sorted_sequence_1d
|
|||
|
|
tensor([1, 3, 5, 7, 9])
|
|||
|
|
>>> torch.searchsorted(sorted_sequence_1d, values)
|
|||
|
|
tensor([[1, 3, 4],
|
|||
|
|
[1, 3, 4]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def segment_reduce(data: Tensor, reduce: str, *, lengths: Optional[Tensor] = None, indices: Optional[Tensor] = None, offsets: Optional[Tensor] = None, axis: _int = 0, unsafe: _bool = False, initial: Optional[Union[Number, _complex]] = None) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def select(input: Tensor, dim: _int, index: Union[_int, SymInt]) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
select(input, dim, index) -> Tensor
|
|||
|
|
|
|||
|
|
Slices the :attr:`input` tensor along the selected dimension at the given index.
|
|||
|
|
This function returns a view of the original tensor with the given dimension removed.
|
|||
|
|
|
|||
|
|
.. note:: If :attr:`input` is a sparse tensor and returning a view of
|
|||
|
|
the tensor is not possible, a RuntimeError exception is
|
|||
|
|
raised. In this is the case, consider using
|
|||
|
|
:func:`torch.select_copy` function.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to slice
|
|||
|
|
index (int): the index to select with
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
:meth:`select` is equivalent to slicing. For example,
|
|||
|
|
``tensor.select(0, index)`` is equivalent to ``tensor[index]`` and
|
|||
|
|
``tensor.select(2, index)`` is equivalent to ``tensor[:,:,index]``.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def select(input: Tensor, dim: Union[str, ellipsis, None], index: _int) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
select(input, dim, index) -> Tensor
|
|||
|
|
|
|||
|
|
Slices the :attr:`input` tensor along the selected dimension at the given index.
|
|||
|
|
This function returns a view of the original tensor with the given dimension removed.
|
|||
|
|
|
|||
|
|
.. note:: If :attr:`input` is a sparse tensor and returning a view of
|
|||
|
|
the tensor is not possible, a RuntimeError exception is
|
|||
|
|
raised. In this is the case, consider using
|
|||
|
|
:func:`torch.select_copy` function.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the dimension to slice
|
|||
|
|
index (int): the index to select with
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
:meth:`select` is equivalent to slicing. For example,
|
|||
|
|
``tensor.select(0, index)`` is equivalent to ``tensor[index]`` and
|
|||
|
|
``tensor.select(2, index)`` is equivalent to ``tensor[:,:,index]``.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def select_copy(input: Tensor, dim: _int, index: Union[_int, SymInt], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.select`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def select_scatter(input: Tensor, src: Tensor, dim: _int, index: Union[_int, SymInt]) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
select_scatter(input, src, dim, index) -> Tensor
|
|||
|
|
|
|||
|
|
Embeds the values of the :attr:`src` tensor into :attr:`input` at the given index.
|
|||
|
|
This function returns a tensor with fresh storage; it does not create a view.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
src (Tensor): The tensor to embed into :attr:`input`
|
|||
|
|
dim (int): the dimension to insert the slice into.
|
|||
|
|
index (int): the index to select with
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
:attr:`src` must be of the proper size in order to be embedded
|
|||
|
|
into :attr:`input`. Specifically, it should have the same shape as
|
|||
|
|
``torch.select(input, dim, index)``
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.zeros(2, 2)
|
|||
|
|
>>> b = torch.ones(2)
|
|||
|
|
>>> a.select_scatter(b, 0, 0)
|
|||
|
|
tensor([[1., 1.],
|
|||
|
|
[0., 0.]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def selu(input: Tensor) -> Tensor: ...
|
|||
|
|
def selu_(input: Tensor) -> Tensor: ...
|
|||
|
|
def set_flush_denormal(mode: _bool) -> _bool:
|
|||
|
|
r"""
|
|||
|
|
set_flush_denormal(mode) -> bool
|
|||
|
|
|
|||
|
|
Disables denormal floating numbers on CPU.
|
|||
|
|
|
|||
|
|
Returns ``True`` if your system supports flushing denormal numbers and it
|
|||
|
|
successfully configures flush denormal mode. :meth:`~torch.set_flush_denormal`
|
|||
|
|
is supported on x86 architectures supporting SSE3 and AArch64 architecture.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
mode (bool): Controls whether to enable flush denormal mode or not
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.set_flush_denormal(True)
|
|||
|
|
True
|
|||
|
|
>>> torch.tensor([1e-323], dtype=torch.float64)
|
|||
|
|
tensor([ 0.], dtype=torch.float64)
|
|||
|
|
>>> torch.set_flush_denormal(False)
|
|||
|
|
True
|
|||
|
|
>>> torch.tensor([1e-323], dtype=torch.float64)
|
|||
|
|
tensor(9.88131e-324 *
|
|||
|
|
[ 1.0000], dtype=torch.float64)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def set_num_interop_threads(num: _int) -> None:
|
|||
|
|
r"""
|
|||
|
|
set_num_interop_threads(int)
|
|||
|
|
|
|||
|
|
Sets the number of threads used for interop parallelism
|
|||
|
|
(e.g. in JIT interpreter) on CPU.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
Can only be called once and before any inter-op parallel work
|
|||
|
|
is started (e.g. JIT execution).
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def set_num_threads(num: _int) -> None:
|
|||
|
|
r"""
|
|||
|
|
set_num_threads(int)
|
|||
|
|
|
|||
|
|
Sets the number of threads used for intraop parallelism on CPU.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
To ensure that the correct number of threads is used, set_num_threads
|
|||
|
|
must be called before running eager, JIT or autograd code.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def sgn(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
sgn(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
This function is an extension of torch.sign() to complex tensors.
|
|||
|
|
It computes a new tensor whose elements have
|
|||
|
|
the same angles as the corresponding elements of :attr:`input` and
|
|||
|
|
absolute values (i.e. magnitudes) of one for complex tensors and
|
|||
|
|
is equivalent to torch.sign() for non-complex tensors.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \begin{cases}
|
|||
|
|
0 & |\text{{input}}_i| == 0 \\
|
|||
|
|
\frac{{\text{{input}}_i}}{|{\text{{input}}_i}|} & \text{otherwise}
|
|||
|
|
\end{cases}
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> t = torch.tensor([3+4j, 7-24j, 0, 1+2j])
|
|||
|
|
>>> t.sgn()
|
|||
|
|
tensor([0.6000+0.8000j, 0.2800-0.9600j, 0.0000+0.0000j, 0.4472+0.8944j])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def sigmoid(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
sigmoid(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.special.expit`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def sigmoid_(input: Tensor) -> Tensor: ...
|
|||
|
|
def sign(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
sign(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the signs of the elements of :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \operatorname{sgn}(\text{input}_{i})
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([0.7, -1.2, 0., 2.3])
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 0.7000, -1.2000, 0.0000, 2.3000])
|
|||
|
|
>>> torch.sign(a)
|
|||
|
|
tensor([ 1., -1., 0., 1.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def signbit(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
signbit(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Tests if each element of :attr:`input` has its sign bit set or not.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([0.7, -1.2, 0., 2.3])
|
|||
|
|
>>> torch.signbit(a)
|
|||
|
|
tensor([ False, True, False, False])
|
|||
|
|
>>> a = torch.tensor([-0.0, 0.0])
|
|||
|
|
>>> torch.signbit(a)
|
|||
|
|
tensor([ True, False])
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
signbit handles signed zeros, so negative zero (-0) returns True.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def sin(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
sin(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the sine of the elements of :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \sin(\text{input}_{i})
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([-0.5461, 0.1347, -2.7266, -0.2746])
|
|||
|
|
>>> torch.sin(a)
|
|||
|
|
tensor([-0.5194, 0.1343, -0.4032, -0.2711])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def sin_(input: Tensor) -> Tensor: ...
|
|||
|
|
def sinc(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
sinc(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.special.sinc`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def sinc_(input: Tensor) -> Tensor: ...
|
|||
|
|
def sinh(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
sinh(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the hyperbolic sine of the elements of
|
|||
|
|
:attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \sinh(\text{input}_{i})
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 0.5380, -0.8632, -0.1265, 0.9399])
|
|||
|
|
>>> torch.sinh(a)
|
|||
|
|
tensor([ 0.5644, -0.9744, -0.1268, 1.0845])
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
When :attr:`input` is on the CPU, the implementation of torch.sinh may use
|
|||
|
|
the Sleef library, which rounds very large results to infinity or negative
|
|||
|
|
infinity. See `here <https://sleef.org/purec.xhtml>`_ for details.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def sinh_(input: Tensor) -> Tensor: ...
|
|||
|
|
def slice_copy(input: Tensor, dim: _int = 0, start: Optional[Union[_int, SymInt]] = None, end: Optional[Union[_int, SymInt]] = None, step: Union[_int, SymInt] = 1, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.slice`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def slice_inverse(input: Tensor, src: Tensor, dim: _int = 0, start: Optional[Union[_int, SymInt]] = None, end: Optional[Union[_int, SymInt]] = None, step: Union[_int, SymInt] = 1) -> Tensor: ...
|
|||
|
|
def slice_scatter(input: Tensor, src: Tensor, dim: _int = 0, start: Optional[Union[_int, SymInt]] = None, end: Optional[Union[_int, SymInt]] = None, step: Union[_int, SymInt] = 1, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
slice_scatter(input, src, dim=0, start=None, end=None, step=1) -> Tensor
|
|||
|
|
|
|||
|
|
Embeds the values of the :attr:`src` tensor into :attr:`input` at the given
|
|||
|
|
dimension.
|
|||
|
|
This function returns a tensor with fresh storage; it does not create a view.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
src (Tensor): The tensor to embed into :attr:`input`
|
|||
|
|
dim (int): the dimension to insert the slice into
|
|||
|
|
start (Optional[int]): the start index of where to insert the slice
|
|||
|
|
end (Optional[int]): the end index of where to insert the slice
|
|||
|
|
step (int): the how many elements to skip in
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.zeros(8, 8)
|
|||
|
|
>>> b = torch.ones(2, 8)
|
|||
|
|
>>> a.slice_scatter(b, start=6)
|
|||
|
|
tensor([[0., 0., 0., 0., 0., 0., 0., 0.],
|
|||
|
|
[0., 0., 0., 0., 0., 0., 0., 0.],
|
|||
|
|
[0., 0., 0., 0., 0., 0., 0., 0.],
|
|||
|
|
[0., 0., 0., 0., 0., 0., 0., 0.],
|
|||
|
|
[0., 0., 0., 0., 0., 0., 0., 0.],
|
|||
|
|
[0., 0., 0., 0., 0., 0., 0., 0.],
|
|||
|
|
[1., 1., 1., 1., 1., 1., 1., 1.],
|
|||
|
|
[1., 1., 1., 1., 1., 1., 1., 1.]])
|
|||
|
|
|
|||
|
|
>>> b = torch.ones(8, 2)
|
|||
|
|
>>> a.slice_scatter(b, dim=1, start=2, end=6, step=2)
|
|||
|
|
tensor([[0., 0., 1., 0., 1., 0., 0., 0.],
|
|||
|
|
[0., 0., 1., 0., 1., 0., 0., 0.],
|
|||
|
|
[0., 0., 1., 0., 1., 0., 0., 0.],
|
|||
|
|
[0., 0., 1., 0., 1., 0., 0., 0.],
|
|||
|
|
[0., 0., 1., 0., 1., 0., 0., 0.],
|
|||
|
|
[0., 0., 1., 0., 1., 0., 0., 0.],
|
|||
|
|
[0., 0., 1., 0., 1., 0., 0., 0.],
|
|||
|
|
[0., 0., 1., 0., 1., 0., 0., 0.]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def slogdet(input: Tensor, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.slogdet:
|
|||
|
|
r"""
|
|||
|
|
slogdet(input) -> (Tensor, Tensor)
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.linalg.slogdet`
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def smm(input: Tensor, mat2: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
smm(input, mat) -> Tensor
|
|||
|
|
|
|||
|
|
Performs a matrix multiplication of the sparse matrix :attr:`input`
|
|||
|
|
with the dense matrix :attr:`mat`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): a sparse matrix to be matrix multiplied
|
|||
|
|
mat (Tensor): a dense matrix to be matrix multiplied
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def softmax(input: Tensor, dim: _int, dtype: Optional[_dtype] = None, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
softmax(input, dim, *, dtype=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.nn.functional.softmax`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def softmax(input: Tensor, dim: Union[str, ellipsis, None], *, dtype: Optional[_dtype] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
softmax(input, dim, *, dtype=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.nn.functional.softmax`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def sort(input: Tensor, *, stable: Optional[_bool], dim: _int = -1, descending: _bool = False, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.sort:
|
|||
|
|
r"""
|
|||
|
|
sort(input, dim=-1, descending=False, stable=False, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
|
|||
|
|
Sorts the elements of the :attr:`input` tensor along a given dimension
|
|||
|
|
in ascending order by value.
|
|||
|
|
|
|||
|
|
If :attr:`dim` is not given, the last dimension of the `input` is chosen.
|
|||
|
|
|
|||
|
|
If :attr:`descending` is ``True`` then the elements are sorted in descending
|
|||
|
|
order by value.
|
|||
|
|
|
|||
|
|
If :attr:`stable` is ``True`` then the sorting routine becomes stable, preserving
|
|||
|
|
the order of equivalent elements.
|
|||
|
|
|
|||
|
|
A namedtuple of (values, indices) is returned, where the `values` are the
|
|||
|
|
sorted values and `indices` are the indices of the elements in the original
|
|||
|
|
`input` tensor.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int, optional): the dimension to sort along
|
|||
|
|
descending (bool, optional): controls the sorting order (ascending or descending)
|
|||
|
|
stable (bool, optional): makes the sorting routine stable, which guarantees that the order
|
|||
|
|
of equivalent elements is preserved.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the output tuple of (`Tensor`, `LongTensor`) that can
|
|||
|
|
be optionally given to be used as output buffers
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(3, 4)
|
|||
|
|
>>> sorted, indices = torch.sort(x)
|
|||
|
|
>>> sorted
|
|||
|
|
tensor([[-0.2162, 0.0608, 0.6719, 2.3332],
|
|||
|
|
[-0.5793, 0.0061, 0.6058, 0.9497],
|
|||
|
|
[-0.5071, 0.3343, 0.9553, 1.0960]])
|
|||
|
|
>>> indices
|
|||
|
|
tensor([[ 1, 0, 2, 3],
|
|||
|
|
[ 3, 1, 0, 2],
|
|||
|
|
[ 0, 3, 1, 2]])
|
|||
|
|
|
|||
|
|
>>> sorted, indices = torch.sort(x, 0)
|
|||
|
|
>>> sorted
|
|||
|
|
tensor([[-0.5071, -0.2162, 0.6719, -0.5793],
|
|||
|
|
[ 0.0608, 0.0061, 0.9497, 0.3343],
|
|||
|
|
[ 0.6058, 0.9553, 1.0960, 2.3332]])
|
|||
|
|
>>> indices
|
|||
|
|
tensor([[ 2, 0, 0, 1],
|
|||
|
|
[ 0, 1, 1, 2],
|
|||
|
|
[ 1, 2, 2, 0]])
|
|||
|
|
>>> x = torch.tensor([0, 1] * 9)
|
|||
|
|
>>> x.sort()
|
|||
|
|
torch.return_types.sort(
|
|||
|
|
values=tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]),
|
|||
|
|
indices=tensor([ 2, 16, 4, 6, 14, 8, 0, 10, 12, 9, 17, 15, 13, 11, 7, 5, 3, 1]))
|
|||
|
|
>>> x.sort(stable=True)
|
|||
|
|
torch.return_types.sort(
|
|||
|
|
values=tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]),
|
|||
|
|
indices=tensor([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 1, 3, 5, 7, 9, 11, 13, 15, 17]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def sort(input: Tensor, dim: _int = -1, descending: _bool = False, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.sort:
|
|||
|
|
r"""
|
|||
|
|
sort(input, dim=-1, descending=False, stable=False, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
|
|||
|
|
Sorts the elements of the :attr:`input` tensor along a given dimension
|
|||
|
|
in ascending order by value.
|
|||
|
|
|
|||
|
|
If :attr:`dim` is not given, the last dimension of the `input` is chosen.
|
|||
|
|
|
|||
|
|
If :attr:`descending` is ``True`` then the elements are sorted in descending
|
|||
|
|
order by value.
|
|||
|
|
|
|||
|
|
If :attr:`stable` is ``True`` then the sorting routine becomes stable, preserving
|
|||
|
|
the order of equivalent elements.
|
|||
|
|
|
|||
|
|
A namedtuple of (values, indices) is returned, where the `values` are the
|
|||
|
|
sorted values and `indices` are the indices of the elements in the original
|
|||
|
|
`input` tensor.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int, optional): the dimension to sort along
|
|||
|
|
descending (bool, optional): controls the sorting order (ascending or descending)
|
|||
|
|
stable (bool, optional): makes the sorting routine stable, which guarantees that the order
|
|||
|
|
of equivalent elements is preserved.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the output tuple of (`Tensor`, `LongTensor`) that can
|
|||
|
|
be optionally given to be used as output buffers
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(3, 4)
|
|||
|
|
>>> sorted, indices = torch.sort(x)
|
|||
|
|
>>> sorted
|
|||
|
|
tensor([[-0.2162, 0.0608, 0.6719, 2.3332],
|
|||
|
|
[-0.5793, 0.0061, 0.6058, 0.9497],
|
|||
|
|
[-0.5071, 0.3343, 0.9553, 1.0960]])
|
|||
|
|
>>> indices
|
|||
|
|
tensor([[ 1, 0, 2, 3],
|
|||
|
|
[ 3, 1, 0, 2],
|
|||
|
|
[ 0, 3, 1, 2]])
|
|||
|
|
|
|||
|
|
>>> sorted, indices = torch.sort(x, 0)
|
|||
|
|
>>> sorted
|
|||
|
|
tensor([[-0.5071, -0.2162, 0.6719, -0.5793],
|
|||
|
|
[ 0.0608, 0.0061, 0.9497, 0.3343],
|
|||
|
|
[ 0.6058, 0.9553, 1.0960, 2.3332]])
|
|||
|
|
>>> indices
|
|||
|
|
tensor([[ 2, 0, 0, 1],
|
|||
|
|
[ 0, 1, 1, 2],
|
|||
|
|
[ 1, 2, 2, 0]])
|
|||
|
|
>>> x = torch.tensor([0, 1] * 9)
|
|||
|
|
>>> x.sort()
|
|||
|
|
torch.return_types.sort(
|
|||
|
|
values=tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]),
|
|||
|
|
indices=tensor([ 2, 16, 4, 6, 14, 8, 0, 10, 12, 9, 17, 15, 13, 11, 7, 5, 3, 1]))
|
|||
|
|
>>> x.sort(stable=True)
|
|||
|
|
torch.return_types.sort(
|
|||
|
|
values=tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]),
|
|||
|
|
indices=tensor([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 1, 3, 5, 7, 9, 11, 13, 15, 17]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def sort(input: Tensor, *, stable: Optional[_bool], dim: Union[str, ellipsis, None], descending: _bool = False, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.sort:
|
|||
|
|
r"""
|
|||
|
|
sort(input, dim=-1, descending=False, stable=False, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
|
|||
|
|
Sorts the elements of the :attr:`input` tensor along a given dimension
|
|||
|
|
in ascending order by value.
|
|||
|
|
|
|||
|
|
If :attr:`dim` is not given, the last dimension of the `input` is chosen.
|
|||
|
|
|
|||
|
|
If :attr:`descending` is ``True`` then the elements are sorted in descending
|
|||
|
|
order by value.
|
|||
|
|
|
|||
|
|
If :attr:`stable` is ``True`` then the sorting routine becomes stable, preserving
|
|||
|
|
the order of equivalent elements.
|
|||
|
|
|
|||
|
|
A namedtuple of (values, indices) is returned, where the `values` are the
|
|||
|
|
sorted values and `indices` are the indices of the elements in the original
|
|||
|
|
`input` tensor.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int, optional): the dimension to sort along
|
|||
|
|
descending (bool, optional): controls the sorting order (ascending or descending)
|
|||
|
|
stable (bool, optional): makes the sorting routine stable, which guarantees that the order
|
|||
|
|
of equivalent elements is preserved.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the output tuple of (`Tensor`, `LongTensor`) that can
|
|||
|
|
be optionally given to be used as output buffers
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(3, 4)
|
|||
|
|
>>> sorted, indices = torch.sort(x)
|
|||
|
|
>>> sorted
|
|||
|
|
tensor([[-0.2162, 0.0608, 0.6719, 2.3332],
|
|||
|
|
[-0.5793, 0.0061, 0.6058, 0.9497],
|
|||
|
|
[-0.5071, 0.3343, 0.9553, 1.0960]])
|
|||
|
|
>>> indices
|
|||
|
|
tensor([[ 1, 0, 2, 3],
|
|||
|
|
[ 3, 1, 0, 2],
|
|||
|
|
[ 0, 3, 1, 2]])
|
|||
|
|
|
|||
|
|
>>> sorted, indices = torch.sort(x, 0)
|
|||
|
|
>>> sorted
|
|||
|
|
tensor([[-0.5071, -0.2162, 0.6719, -0.5793],
|
|||
|
|
[ 0.0608, 0.0061, 0.9497, 0.3343],
|
|||
|
|
[ 0.6058, 0.9553, 1.0960, 2.3332]])
|
|||
|
|
>>> indices
|
|||
|
|
tensor([[ 2, 0, 0, 1],
|
|||
|
|
[ 0, 1, 1, 2],
|
|||
|
|
[ 1, 2, 2, 0]])
|
|||
|
|
>>> x = torch.tensor([0, 1] * 9)
|
|||
|
|
>>> x.sort()
|
|||
|
|
torch.return_types.sort(
|
|||
|
|
values=tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]),
|
|||
|
|
indices=tensor([ 2, 16, 4, 6, 14, 8, 0, 10, 12, 9, 17, 15, 13, 11, 7, 5, 3, 1]))
|
|||
|
|
>>> x.sort(stable=True)
|
|||
|
|
torch.return_types.sort(
|
|||
|
|
values=tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]),
|
|||
|
|
indices=tensor([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 1, 3, 5, 7, 9, 11, 13, 15, 17]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def sort(input: Tensor, dim: Union[str, ellipsis, None], descending: _bool = False, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.sort:
|
|||
|
|
r"""
|
|||
|
|
sort(input, dim=-1, descending=False, stable=False, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
|
|||
|
|
Sorts the elements of the :attr:`input` tensor along a given dimension
|
|||
|
|
in ascending order by value.
|
|||
|
|
|
|||
|
|
If :attr:`dim` is not given, the last dimension of the `input` is chosen.
|
|||
|
|
|
|||
|
|
If :attr:`descending` is ``True`` then the elements are sorted in descending
|
|||
|
|
order by value.
|
|||
|
|
|
|||
|
|
If :attr:`stable` is ``True`` then the sorting routine becomes stable, preserving
|
|||
|
|
the order of equivalent elements.
|
|||
|
|
|
|||
|
|
A namedtuple of (values, indices) is returned, where the `values` are the
|
|||
|
|
sorted values and `indices` are the indices of the elements in the original
|
|||
|
|
`input` tensor.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int, optional): the dimension to sort along
|
|||
|
|
descending (bool, optional): controls the sorting order (ascending or descending)
|
|||
|
|
stable (bool, optional): makes the sorting routine stable, which guarantees that the order
|
|||
|
|
of equivalent elements is preserved.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the output tuple of (`Tensor`, `LongTensor`) that can
|
|||
|
|
be optionally given to be used as output buffers
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(3, 4)
|
|||
|
|
>>> sorted, indices = torch.sort(x)
|
|||
|
|
>>> sorted
|
|||
|
|
tensor([[-0.2162, 0.0608, 0.6719, 2.3332],
|
|||
|
|
[-0.5793, 0.0061, 0.6058, 0.9497],
|
|||
|
|
[-0.5071, 0.3343, 0.9553, 1.0960]])
|
|||
|
|
>>> indices
|
|||
|
|
tensor([[ 1, 0, 2, 3],
|
|||
|
|
[ 3, 1, 0, 2],
|
|||
|
|
[ 0, 3, 1, 2]])
|
|||
|
|
|
|||
|
|
>>> sorted, indices = torch.sort(x, 0)
|
|||
|
|
>>> sorted
|
|||
|
|
tensor([[-0.5071, -0.2162, 0.6719, -0.5793],
|
|||
|
|
[ 0.0608, 0.0061, 0.9497, 0.3343],
|
|||
|
|
[ 0.6058, 0.9553, 1.0960, 2.3332]])
|
|||
|
|
>>> indices
|
|||
|
|
tensor([[ 2, 0, 0, 1],
|
|||
|
|
[ 0, 1, 1, 2],
|
|||
|
|
[ 1, 2, 2, 0]])
|
|||
|
|
>>> x = torch.tensor([0, 1] * 9)
|
|||
|
|
>>> x.sort()
|
|||
|
|
torch.return_types.sort(
|
|||
|
|
values=tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]),
|
|||
|
|
indices=tensor([ 2, 16, 4, 6, 14, 8, 0, 10, 12, 9, 17, 15, 13, 11, 7, 5, 3, 1]))
|
|||
|
|
>>> x.sort(stable=True)
|
|||
|
|
torch.return_types.sort(
|
|||
|
|
values=tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]),
|
|||
|
|
indices=tensor([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 1, 3, 5, 7, 9, 11, 13, 15, 17]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def sparse_bsc_tensor(ccol_indices: Union[Tensor, List], row_indices: Union[Tensor, List], values: Union[Tensor, List], size: Optional[_size] = None, *, dtype: Optional[_dtype] = None, device: Optional[DeviceLikeType] = None, requires_grad: _bool = False, check_invariants: Optional[_bool] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
sparse_bsc_tensor(ccol_indices, row_indices, values, size=None, *, dtype=None, device=None, requires_grad=False, check_invariants=None) -> Tensor
|
|||
|
|
|
|||
|
|
Constructs a :ref:`sparse tensor in BSC (Block Compressed Sparse
|
|||
|
|
Column)) <sparse-bsc-docs>` with specified 2-dimensional blocks at the
|
|||
|
|
given :attr:`ccol_indices` and :attr:`row_indices`. Sparse matrix
|
|||
|
|
multiplication operations in BSC format are typically faster than that
|
|||
|
|
for sparse tensors in COO format. Make you have a look at :ref:`the
|
|||
|
|
note on the data type of the indices <sparse-bsc-docs>`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
If the ``device`` argument is not specified the device of the given
|
|||
|
|
:attr:`values` and indices tensor(s) must match. If, however, the
|
|||
|
|
argument is specified the input Tensors will be converted to the
|
|||
|
|
given device and in turn determine the device of the constructed
|
|||
|
|
sparse tensor.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
ccol_indices (array_like): (B+1)-dimensional array of size
|
|||
|
|
``(*batchsize, ncolblocks + 1)``. The last element of each
|
|||
|
|
batch is the number of non-zeros. This tensor encodes the
|
|||
|
|
index in values and row_indices depending on where the given
|
|||
|
|
column starts. Each successive number in the tensor subtracted
|
|||
|
|
by the number before it denotes the number of elements in a
|
|||
|
|
given column.
|
|||
|
|
row_indices (array_like): Row block co-ordinates of each block in
|
|||
|
|
values. (B+1)-dimensional tensor with the same length
|
|||
|
|
as values.
|
|||
|
|
values (array_list): Initial blocks for the tensor. Can be a list,
|
|||
|
|
tuple, NumPy ``ndarray``, and other types that
|
|||
|
|
represents a (1 + 2 + K)-dimensional tensor where ``K`` is the
|
|||
|
|
number of dense dimensions.
|
|||
|
|
size (list, tuple, :class:`torch.Size`, optional): Size of the
|
|||
|
|
sparse tensor: ``(*batchsize, nrows * blocksize[0], ncols *
|
|||
|
|
blocksize[1], *densesize)`` If not provided, the size will be
|
|||
|
|
inferred as the minimum size big enough to hold all non-zero
|
|||
|
|
blocks.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of
|
|||
|
|
returned tensor. Default: if None, infers data type from
|
|||
|
|
:attr:`values`.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of
|
|||
|
|
returned tensor. Default: if None, uses the current device
|
|||
|
|
for the default tensor type (see
|
|||
|
|
:func:`torch.set_default_device`). :attr:`device` will be
|
|||
|
|
the CPU for CPU tensor types and the current CUDA device for
|
|||
|
|
CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
check_invariants (bool, optional): If sparse tensor invariants are checked.
|
|||
|
|
Default: as returned by :func:`torch.sparse.check_sparse_tensor_invariants.is_enabled`,
|
|||
|
|
initially False.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
>>> ccol_indices = [0, 1, 2]
|
|||
|
|
>>> row_indices = [0, 1]
|
|||
|
|
>>> values = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
|
|||
|
|
>>> torch.sparse_bsc_tensor(torch.tensor(ccol_indices, dtype=torch.int64),
|
|||
|
|
... torch.tensor(row_indices, dtype=torch.int64),
|
|||
|
|
... torch.tensor(values), dtype=torch.double)
|
|||
|
|
tensor(ccol_indices=tensor([0, 1, 2]),
|
|||
|
|
row_indices=tensor([0, 1]),
|
|||
|
|
values=tensor([[[1., 2.],
|
|||
|
|
[3., 4.]],
|
|||
|
|
[[5., 6.],
|
|||
|
|
[7., 8.]]]), size=(2, 2), nnz=2, dtype=torch.float64,
|
|||
|
|
layout=torch.sparse_bsc)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def sparse_bsr_tensor(crow_indices: Union[Tensor, List], col_indices: Union[Tensor, List], values: Union[Tensor, List], size: Optional[_size] = None, *, dtype: Optional[_dtype] = None, device: Optional[DeviceLikeType] = None, requires_grad: _bool = False, check_invariants: Optional[_bool] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
sparse_bsr_tensor(crow_indices, col_indices, values, size=None, *, dtype=None, device=None, requires_grad=False, check_invariants=None) -> Tensor
|
|||
|
|
|
|||
|
|
Constructs a :ref:`sparse tensor in BSR (Block Compressed Sparse Row))
|
|||
|
|
<sparse-bsr-docs>` with specified 2-dimensional blocks at the given
|
|||
|
|
:attr:`crow_indices` and :attr:`col_indices`. Sparse matrix
|
|||
|
|
multiplication operations in BSR format are typically faster than that
|
|||
|
|
for sparse tensors in COO format. Make you have a look at :ref:`the
|
|||
|
|
note on the data type of the indices <sparse-bsr-docs>`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
If the ``device`` argument is not specified the device of the given
|
|||
|
|
:attr:`values` and indices tensor(s) must match. If, however, the
|
|||
|
|
argument is specified the input Tensors will be converted to the
|
|||
|
|
given device and in turn determine the device of the constructed
|
|||
|
|
sparse tensor.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
crow_indices (array_like): (B+1)-dimensional array of size
|
|||
|
|
``(*batchsize, nrowblocks + 1)``. The last element of each
|
|||
|
|
batch is the number of non-zeros. This tensor encodes the
|
|||
|
|
block index in values and col_indices depending on where the
|
|||
|
|
given row block starts. Each successive number in the tensor
|
|||
|
|
subtracted by the number before it denotes the number of
|
|||
|
|
blocks in a given row.
|
|||
|
|
col_indices (array_like): Column block co-ordinates of each block
|
|||
|
|
in values. (B+1)-dimensional tensor with the same length as
|
|||
|
|
values.
|
|||
|
|
values (array_list): Initial values for the tensor. Can be a list,
|
|||
|
|
tuple, NumPy ``ndarray``, scalar, and other types that
|
|||
|
|
represents a (1 + 2 + K)-dimensional tensor where ``K`` is the
|
|||
|
|
number of dense dimensions.
|
|||
|
|
size (list, tuple, :class:`torch.Size`, optional): Size of the
|
|||
|
|
sparse tensor: ``(*batchsize, nrows * blocksize[0], ncols *
|
|||
|
|
blocksize[1], *densesize)`` where ``blocksize ==
|
|||
|
|
values.shape[1:3]``. If not provided, the size will be
|
|||
|
|
inferred as the minimum size big enough to hold all non-zero
|
|||
|
|
blocks.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of
|
|||
|
|
returned tensor. Default: if None, infers data type from
|
|||
|
|
:attr:`values`.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of
|
|||
|
|
returned tensor. Default: if None, uses the current device
|
|||
|
|
for the default tensor type (see
|
|||
|
|
:func:`torch.set_default_device`). :attr:`device` will be
|
|||
|
|
the CPU for CPU tensor types and the current CUDA device for
|
|||
|
|
CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
check_invariants (bool, optional): If sparse tensor invariants are checked.
|
|||
|
|
Default: as returned by :func:`torch.sparse.check_sparse_tensor_invariants.is_enabled`,
|
|||
|
|
initially False.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
>>> crow_indices = [0, 1, 2]
|
|||
|
|
>>> col_indices = [0, 1]
|
|||
|
|
>>> values = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
|
|||
|
|
>>> torch.sparse_bsr_tensor(torch.tensor(crow_indices, dtype=torch.int64),
|
|||
|
|
... torch.tensor(col_indices, dtype=torch.int64),
|
|||
|
|
... torch.tensor(values), dtype=torch.double)
|
|||
|
|
tensor(crow_indices=tensor([0, 1, 2]),
|
|||
|
|
col_indices=tensor([0, 1]),
|
|||
|
|
values=tensor([[[1., 2.],
|
|||
|
|
[3., 4.]],
|
|||
|
|
[[5., 6.],
|
|||
|
|
[7., 8.]]]), size=(2, 2), nnz=2, dtype=torch.float64,
|
|||
|
|
layout=torch.sparse_bsr)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def sparse_compressed_tensor(compressed_indices: Union[Tensor, List], plain_indices: Union[Tensor, List], values: Union[Tensor, List], size: Optional[_size] = None, *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[DeviceLikeType] = None, requires_grad: _bool = False, check_invariants: Optional[_bool] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
sparse_compressed_tensor(compressed_indices, plain_indices, values, size=None, *, dtype=None, layout=None, device=None, requires_grad=False, check_invariants=None) -> Tensor
|
|||
|
|
|
|||
|
|
Constructs a :ref:`sparse tensor in Compressed Sparse format - CSR,
|
|||
|
|
CSC, BSR, or BSC - <sparse-compressed-docs>` with specified values at
|
|||
|
|
the given :attr:`compressed_indices` and :attr:`plain_indices`. Sparse
|
|||
|
|
matrix multiplication operations in Compressed Sparse format are
|
|||
|
|
typically faster than that for sparse tensors in COO format. Make you
|
|||
|
|
have a look at :ref:`the note on the data type of the indices
|
|||
|
|
<sparse-compressed-docs>`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
If the ``device`` argument is not specified the device of the given
|
|||
|
|
:attr:`values` and indices tensor(s) must match. If, however, the
|
|||
|
|
argument is specified the input Tensors will be converted to the
|
|||
|
|
given device and in turn determine the device of the constructed
|
|||
|
|
sparse tensor.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
compressed_indices (array_like): (B+1)-dimensional array of size
|
|||
|
|
``(*batchsize, compressed_dim_size + 1)``. The last element of
|
|||
|
|
each batch is the number of non-zero elements or blocks. This
|
|||
|
|
tensor encodes the index in ``values`` and ``plain_indices``
|
|||
|
|
depending on where the given compressed dimension (row or
|
|||
|
|
column) starts. Each successive number in the tensor
|
|||
|
|
subtracted by the number before it denotes the number of
|
|||
|
|
elements or blocks in a given compressed dimension.
|
|||
|
|
plain_indices (array_like): Plain dimension (column or row)
|
|||
|
|
co-ordinates of each element or block in values. (B+1)-dimensional
|
|||
|
|
tensor with the same length as values.
|
|||
|
|
|
|||
|
|
values (array_list): Initial values for the tensor. Can be a list,
|
|||
|
|
tuple, NumPy ``ndarray``, scalar, and other types. that
|
|||
|
|
represents a (1+K)-dimensional (for CSR and CSC layouts) or
|
|||
|
|
(1+2+K)-dimensional tensor (for BSR and BSC layouts) where
|
|||
|
|
``K`` is the number of dense dimensions.
|
|||
|
|
size (list, tuple, :class:`torch.Size`, optional): Size of the
|
|||
|
|
sparse tensor: ``(*batchsize, nrows * blocksize[0], ncols *
|
|||
|
|
blocksize[1], *densesize)`` where ``blocksize[0] ==
|
|||
|
|
blocksize[1] == 1`` for CSR and CSC formats. If not provided,
|
|||
|
|
the size will be inferred as the minimum size big enough to
|
|||
|
|
hold all non-zero elements or blocks.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of
|
|||
|
|
returned tensor. Default: if None, infers data type from
|
|||
|
|
:attr:`values`.
|
|||
|
|
layout (:class:`torch.layout`, required): the desired layout of
|
|||
|
|
returned tensor: :attr:`torch.sparse_csr`,
|
|||
|
|
:attr:`torch.sparse_csc`, :attr:`torch.sparse_bsr`, or
|
|||
|
|
:attr:`torch.sparse_bsc`.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of
|
|||
|
|
returned tensor. Default: if None, uses the current device
|
|||
|
|
for the default tensor type (see
|
|||
|
|
:func:`torch.set_default_device`). :attr:`device` will be
|
|||
|
|
the CPU for CPU tensor types and the current CUDA device for
|
|||
|
|
CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
check_invariants (bool, optional): If sparse tensor invariants are checked.
|
|||
|
|
Default: as returned by :func:`torch.sparse.check_sparse_tensor_invariants.is_enabled`,
|
|||
|
|
initially False.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
>>> compressed_indices = [0, 2, 4]
|
|||
|
|
>>> plain_indices = [0, 1, 0, 1]
|
|||
|
|
>>> values = [1, 2, 3, 4]
|
|||
|
|
>>> torch.sparse_compressed_tensor(torch.tensor(compressed_indices, dtype=torch.int64),
|
|||
|
|
... torch.tensor(plain_indices, dtype=torch.int64),
|
|||
|
|
... torch.tensor(values), dtype=torch.double, layout=torch.sparse_csr)
|
|||
|
|
tensor(crow_indices=tensor([0, 2, 4]),
|
|||
|
|
col_indices=tensor([0, 1, 0, 1]),
|
|||
|
|
values=tensor([1., 2., 3., 4.]), size=(2, 2), nnz=4,
|
|||
|
|
dtype=torch.float64, layout=torch.sparse_csr)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def sparse_coo_tensor(indices: Tensor, values: Union[Tensor, List], size: Optional[_size] = None, *, dtype: Optional[_dtype] = None, device: Optional[DeviceLikeType] = None, requires_grad: _bool = False, check_invariants: Optional[_bool] = None, is_coalesced: Optional[_bool] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
sparse_coo_tensor(indices, values, size=None, *, dtype=None, device=None, requires_grad=False, check_invariants=None, is_coalesced=None) -> Tensor
|
|||
|
|
|
|||
|
|
Constructs a :ref:`sparse tensor in COO(rdinate) format
|
|||
|
|
<sparse-coo-docs>` with specified values at the given
|
|||
|
|
:attr:`indices`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
This function returns an :ref:`uncoalesced tensor
|
|||
|
|
<sparse-uncoalesced-coo-docs>` when :attr:`is_coalesced` is
|
|||
|
|
unspecified or ``None``.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
If the ``device`` argument is not specified the device of the given
|
|||
|
|
:attr:`values` and indices tensor(s) must match. If, however, the
|
|||
|
|
argument is specified the input Tensors will be converted to the
|
|||
|
|
given device and in turn determine the device of the constructed
|
|||
|
|
sparse tensor.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
indices (array_like): Initial data for the tensor. Can be a list, tuple,
|
|||
|
|
NumPy ``ndarray``, scalar, and other types. Will be cast to a :class:`torch.LongTensor`
|
|||
|
|
internally. The indices are the coordinates of the non-zero values in the matrix, and thus
|
|||
|
|
should be two-dimensional where the first dimension is the number of tensor dimensions and
|
|||
|
|
the second dimension is the number of non-zero values.
|
|||
|
|
values (array_like): Initial values for the tensor. Can be a list, tuple,
|
|||
|
|
NumPy ``ndarray``, scalar, and other types.
|
|||
|
|
size (list, tuple, or :class:`torch.Size`, optional): Size of the sparse tensor. If not
|
|||
|
|
provided the size will be inferred as the minimum size big enough to hold all non-zero
|
|||
|
|
elements.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if None, infers data type from :attr:`values`.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if None, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
check_invariants (bool, optional): If sparse tensor invariants are checked.
|
|||
|
|
Default: as returned by :func:`torch.sparse.check_sparse_tensor_invariants.is_enabled`,
|
|||
|
|
initially False.
|
|||
|
|
is_coalesced (bool, optional): When``True``, the caller is
|
|||
|
|
responsible for providing tensor indices that correspond to a
|
|||
|
|
coalesced tensor. If the :attr:`check_invariants` flag is
|
|||
|
|
False, no error will be raised if the prerequisites are not
|
|||
|
|
met and this will lead to silently incorrect results. To force
|
|||
|
|
coalescion please use :meth:`coalesce` on the resulting
|
|||
|
|
Tensor.
|
|||
|
|
Default: None: except for trivial cases (e.g. nnz < 2) the
|
|||
|
|
resulting Tensor has is_coalesced set to ``False```.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> i = torch.tensor([[0, 1, 1],
|
|||
|
|
... [2, 0, 2]])
|
|||
|
|
>>> v = torch.tensor([3, 4, 5], dtype=torch.float32)
|
|||
|
|
>>> torch.sparse_coo_tensor(i, v, [2, 4])
|
|||
|
|
tensor(indices=tensor([[0, 1, 1],
|
|||
|
|
[2, 0, 2]]),
|
|||
|
|
values=tensor([3., 4., 5.]),
|
|||
|
|
size=(2, 4), nnz=3, layout=torch.sparse_coo)
|
|||
|
|
|
|||
|
|
>>> torch.sparse_coo_tensor(i, v) # Shape inference
|
|||
|
|
tensor(indices=tensor([[0, 1, 1],
|
|||
|
|
[2, 0, 2]]),
|
|||
|
|
values=tensor([3., 4., 5.]),
|
|||
|
|
size=(2, 3), nnz=3, layout=torch.sparse_coo)
|
|||
|
|
|
|||
|
|
>>> torch.sparse_coo_tensor(i, v, [2, 4],
|
|||
|
|
... dtype=torch.float64,
|
|||
|
|
... device=torch.device('cuda:0'))
|
|||
|
|
tensor(indices=tensor([[0, 1, 1],
|
|||
|
|
[2, 0, 2]]),
|
|||
|
|
values=tensor([3., 4., 5.]),
|
|||
|
|
device='cuda:0', size=(2, 4), nnz=3, dtype=torch.float64,
|
|||
|
|
layout=torch.sparse_coo)
|
|||
|
|
|
|||
|
|
# Create an empty sparse tensor with the following invariants:
|
|||
|
|
# 1. sparse_dim + dense_dim = len(SparseTensor.shape)
|
|||
|
|
# 2. SparseTensor._indices().shape = (sparse_dim, nnz)
|
|||
|
|
# 3. SparseTensor._values().shape = (nnz, SparseTensor.shape[sparse_dim:])
|
|||
|
|
#
|
|||
|
|
# For instance, to create an empty sparse tensor with nnz = 0, dense_dim = 0 and
|
|||
|
|
# sparse_dim = 1 (hence indices is a 2D tensor of shape = (1, 0))
|
|||
|
|
>>> S = torch.sparse_coo_tensor(torch.empty([1, 0]), [], [1])
|
|||
|
|
tensor(indices=tensor([], size=(1, 0)),
|
|||
|
|
values=tensor([], size=(0,)),
|
|||
|
|
size=(1,), nnz=0, layout=torch.sparse_coo)
|
|||
|
|
|
|||
|
|
# and to create an empty sparse tensor with nnz = 0, dense_dim = 1 and
|
|||
|
|
# sparse_dim = 1
|
|||
|
|
>>> S = torch.sparse_coo_tensor(torch.empty([1, 0]), torch.empty([0, 2]), [1, 2])
|
|||
|
|
tensor(indices=tensor([], size=(1, 0)),
|
|||
|
|
values=tensor([], size=(0, 2)),
|
|||
|
|
size=(1, 2), nnz=0, layout=torch.sparse_coo)
|
|||
|
|
|
|||
|
|
.. _torch.sparse: https://pytorch.org/docs/stable/sparse.html
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def sparse_csc_tensor(ccol_indices: Union[Tensor, List], row_indices: Union[Tensor, List], values: Union[Tensor, List], size: Optional[_size] = None, *, dtype: Optional[_dtype] = None, device: Optional[DeviceLikeType] = None, requires_grad: _bool = False, check_invariants: Optional[_bool] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
sparse_csc_tensor(ccol_indices, row_indices, values, size=None, *, dtype=None, device=None, requires_grad=False, check_invariants=None) -> Tensor
|
|||
|
|
|
|||
|
|
Constructs a :ref:`sparse tensor in CSC (Compressed Sparse Column)
|
|||
|
|
<sparse-csc-docs>` with specified values at the given
|
|||
|
|
:attr:`ccol_indices` and :attr:`row_indices`. Sparse matrix
|
|||
|
|
multiplication operations in CSC format are typically faster than that
|
|||
|
|
for sparse tensors in COO format. Make you have a look at :ref:`the
|
|||
|
|
note on the data type of the indices <sparse-csc-docs>`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
If the ``device`` argument is not specified the device of the given
|
|||
|
|
:attr:`values` and indices tensor(s) must match. If, however, the
|
|||
|
|
argument is specified the input Tensors will be converted to the
|
|||
|
|
given device and in turn determine the device of the constructed
|
|||
|
|
sparse tensor.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
ccol_indices (array_like): (B+1)-dimensional array of size
|
|||
|
|
``(*batchsize, ncols + 1)``. The last element of each batch
|
|||
|
|
is the number of non-zeros. This tensor encodes the index in
|
|||
|
|
values and row_indices depending on where the given column
|
|||
|
|
starts. Each successive number in the tensor subtracted by the
|
|||
|
|
number before it denotes the number of elements in a given
|
|||
|
|
column.
|
|||
|
|
row_indices (array_like): Row co-ordinates of each element in
|
|||
|
|
values. (B+1)-dimensional tensor with the same length as
|
|||
|
|
values.
|
|||
|
|
values (array_list): Initial values for the tensor. Can be a list,
|
|||
|
|
tuple, NumPy ``ndarray``, scalar, and other types that
|
|||
|
|
represents a (1+K)-dimensional tensor where ``K`` is the number
|
|||
|
|
of dense dimensions.
|
|||
|
|
size (list, tuple, :class:`torch.Size`, optional): Size of the
|
|||
|
|
sparse tensor: ``(*batchsize, nrows, ncols, *densesize)``. If
|
|||
|
|
not provided, the size will be inferred as the minimum size
|
|||
|
|
big enough to hold all non-zero elements.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of
|
|||
|
|
returned tensor. Default: if None, infers data type from
|
|||
|
|
:attr:`values`.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of
|
|||
|
|
returned tensor. Default: if None, uses the current device
|
|||
|
|
for the default tensor type (see
|
|||
|
|
:func:`torch.set_default_device`). :attr:`device` will be
|
|||
|
|
the CPU for CPU tensor types and the current CUDA device for
|
|||
|
|
CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
check_invariants (bool, optional): If sparse tensor invariants are checked.
|
|||
|
|
Default: as returned by :func:`torch.sparse.check_sparse_tensor_invariants.is_enabled`,
|
|||
|
|
initially False.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
>>> ccol_indices = [0, 2, 4]
|
|||
|
|
>>> row_indices = [0, 1, 0, 1]
|
|||
|
|
>>> values = [1, 2, 3, 4]
|
|||
|
|
>>> torch.sparse_csc_tensor(torch.tensor(ccol_indices, dtype=torch.int64),
|
|||
|
|
... torch.tensor(row_indices, dtype=torch.int64),
|
|||
|
|
... torch.tensor(values), dtype=torch.double)
|
|||
|
|
tensor(ccol_indices=tensor([0, 2, 4]),
|
|||
|
|
row_indices=tensor([0, 1, 0, 1]),
|
|||
|
|
values=tensor([1., 2., 3., 4.]), size=(2, 2), nnz=4,
|
|||
|
|
dtype=torch.float64, layout=torch.sparse_csc)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def sparse_csr_tensor(crow_indices: Union[Tensor, List], col_indices: Union[Tensor, List], values: Union[Tensor, List], size: Optional[_size] = None, *, dtype: Optional[_dtype] = None, device: Optional[DeviceLikeType] = None, requires_grad: _bool = False, check_invariants: Optional[_bool] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
sparse_csr_tensor(crow_indices, col_indices, values, size=None, *, dtype=None, device=None, requires_grad=False, check_invariants=None) -> Tensor
|
|||
|
|
|
|||
|
|
Constructs a :ref:`sparse tensor in CSR (Compressed Sparse Row) <sparse-csr-docs>` with specified
|
|||
|
|
values at the given :attr:`crow_indices` and :attr:`col_indices`. Sparse matrix multiplication operations
|
|||
|
|
in CSR format are typically faster than that for sparse tensors in COO format. Make you have a look
|
|||
|
|
at :ref:`the note on the data type of the indices <sparse-csr-docs>`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
If the ``device`` argument is not specified the device of the given
|
|||
|
|
:attr:`values` and indices tensor(s) must match. If, however, the
|
|||
|
|
argument is specified the input Tensors will be converted to the
|
|||
|
|
given device and in turn determine the device of the constructed
|
|||
|
|
sparse tensor.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
crow_indices (array_like): (B+1)-dimensional array of size
|
|||
|
|
``(*batchsize, nrows + 1)``. The last element of each batch
|
|||
|
|
is the number of non-zeros. This tensor encodes the index in
|
|||
|
|
values and col_indices depending on where the given row
|
|||
|
|
starts. Each successive number in the tensor subtracted by the
|
|||
|
|
number before it denotes the number of elements in a given
|
|||
|
|
row.
|
|||
|
|
col_indices (array_like): Column co-ordinates of each element in
|
|||
|
|
values. (B+1)-dimensional tensor with the same length
|
|||
|
|
as values.
|
|||
|
|
values (array_list): Initial values for the tensor. Can be a list,
|
|||
|
|
tuple, NumPy ``ndarray``, scalar, and other types that
|
|||
|
|
represents a (1+K)-dimensional tensor where ``K`` is the number
|
|||
|
|
of dense dimensions.
|
|||
|
|
size (list, tuple, :class:`torch.Size`, optional): Size of the
|
|||
|
|
sparse tensor: ``(*batchsize, nrows, ncols, *densesize)``. If
|
|||
|
|
not provided, the size will be inferred as the minimum size
|
|||
|
|
big enough to hold all non-zero elements.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of
|
|||
|
|
returned tensor. Default: if None, infers data type from
|
|||
|
|
:attr:`values`.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of
|
|||
|
|
returned tensor. Default: if None, uses the current device
|
|||
|
|
for the default tensor type (see
|
|||
|
|
:func:`torch.set_default_device`). :attr:`device` will be
|
|||
|
|
the CPU for CPU tensor types and the current CUDA device for
|
|||
|
|
CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
check_invariants (bool, optional): If sparse tensor invariants are checked.
|
|||
|
|
Default: as returned by :func:`torch.sparse.check_sparse_tensor_invariants.is_enabled`,
|
|||
|
|
initially False.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
>>> crow_indices = [0, 2, 4]
|
|||
|
|
>>> col_indices = [0, 1, 0, 1]
|
|||
|
|
>>> values = [1, 2, 3, 4]
|
|||
|
|
>>> torch.sparse_csr_tensor(torch.tensor(crow_indices, dtype=torch.int64),
|
|||
|
|
... torch.tensor(col_indices, dtype=torch.int64),
|
|||
|
|
... torch.tensor(values), dtype=torch.double)
|
|||
|
|
tensor(crow_indices=tensor([0, 2, 4]),
|
|||
|
|
col_indices=tensor([0, 1, 0, 1]),
|
|||
|
|
values=tensor([1., 2., 3., 4.]), size=(2, 2), nnz=4,
|
|||
|
|
dtype=torch.float64, layout=torch.sparse_csr)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def split_copy(input: Tensor, split_size: Union[_int, SymInt], dim: _int = 0, *, out: Union[Tuple[Tensor, ...], List[Tensor], None] = None) -> None:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.split`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def split_with_sizes(input: Tensor, split_sizes: Sequence[Union[_int, SymInt]], dim: _int = 0) -> Tuple[Tensor, ...]: ...
|
|||
|
|
def split_with_sizes_copy(input: Tensor, split_sizes: Sequence[Union[_int, SymInt]], dim: _int = 0, *, out: Union[Tuple[Tensor, ...], List[Tensor], None] = None) -> None:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.split_with_sizes`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def spmm(input: Tensor, mat2: Tensor) -> Tensor: ...
|
|||
|
|
def sqrt(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
sqrt(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the square-root of the elements of :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \sqrt{\text{input}_{i}}
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([-2.0755, 1.0226, 0.0831, 0.4806])
|
|||
|
|
>>> torch.sqrt(a)
|
|||
|
|
tensor([ nan, 1.0112, 0.2883, 0.6933])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def sqrt_(input: Tensor) -> Tensor: ...
|
|||
|
|
def square(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
square(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the square of the elements of :attr:`input`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([-2.0755, 1.0226, 0.0831, 0.4806])
|
|||
|
|
>>> torch.square(a)
|
|||
|
|
tensor([ 4.3077, 1.0457, 0.0069, 0.2310])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def square_(input: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def squeeze(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
squeeze(input, dim=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor with all specified dimensions of :attr:`input` of size `1` removed.
|
|||
|
|
|
|||
|
|
For example, if `input` is of shape:
|
|||
|
|
:math:`(A \times 1 \times B \times C \times 1 \times D)` then the `input.squeeze()`
|
|||
|
|
will be of shape: :math:`(A \times B \times C \times D)`.
|
|||
|
|
|
|||
|
|
When :attr:`dim` is given, a squeeze operation is done only in the given
|
|||
|
|
dimension(s). If `input` is of shape: :math:`(A \times 1 \times B)`,
|
|||
|
|
``squeeze(input, 0)`` leaves the tensor unchanged, but ``squeeze(input, 1)``
|
|||
|
|
will squeeze the tensor to the shape :math:`(A \times B)`.
|
|||
|
|
|
|||
|
|
.. note:: The returned tensor shares the storage with the input tensor,
|
|||
|
|
so changing the contents of one will change the contents of the other.
|
|||
|
|
|
|||
|
|
.. warning:: If the tensor has a batch dimension of size 1, then `squeeze(input)`
|
|||
|
|
will also remove the batch dimension, which can lead to unexpected
|
|||
|
|
errors. Consider specifying only the dims you wish to be squeezed.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints, optional): if given, the input will be squeezed
|
|||
|
|
only in the specified dimensions.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
:attr:`dim` now accepts tuples of dimensions.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.zeros(2, 1, 2, 1, 2)
|
|||
|
|
>>> x.size()
|
|||
|
|
torch.Size([2, 1, 2, 1, 2])
|
|||
|
|
>>> y = torch.squeeze(x)
|
|||
|
|
>>> y.size()
|
|||
|
|
torch.Size([2, 2, 2])
|
|||
|
|
>>> y = torch.squeeze(x, 0)
|
|||
|
|
>>> y.size()
|
|||
|
|
torch.Size([2, 1, 2, 1, 2])
|
|||
|
|
>>> y = torch.squeeze(x, 1)
|
|||
|
|
>>> y.size()
|
|||
|
|
torch.Size([2, 2, 1, 2])
|
|||
|
|
>>> y = torch.squeeze(x, (1, 2, 3))
|
|||
|
|
torch.Size([2, 2, 2])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def squeeze(input: Tensor, dim: _int) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
squeeze(input, dim=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor with all specified dimensions of :attr:`input` of size `1` removed.
|
|||
|
|
|
|||
|
|
For example, if `input` is of shape:
|
|||
|
|
:math:`(A \times 1 \times B \times C \times 1 \times D)` then the `input.squeeze()`
|
|||
|
|
will be of shape: :math:`(A \times B \times C \times D)`.
|
|||
|
|
|
|||
|
|
When :attr:`dim` is given, a squeeze operation is done only in the given
|
|||
|
|
dimension(s). If `input` is of shape: :math:`(A \times 1 \times B)`,
|
|||
|
|
``squeeze(input, 0)`` leaves the tensor unchanged, but ``squeeze(input, 1)``
|
|||
|
|
will squeeze the tensor to the shape :math:`(A \times B)`.
|
|||
|
|
|
|||
|
|
.. note:: The returned tensor shares the storage with the input tensor,
|
|||
|
|
so changing the contents of one will change the contents of the other.
|
|||
|
|
|
|||
|
|
.. warning:: If the tensor has a batch dimension of size 1, then `squeeze(input)`
|
|||
|
|
will also remove the batch dimension, which can lead to unexpected
|
|||
|
|
errors. Consider specifying only the dims you wish to be squeezed.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints, optional): if given, the input will be squeezed
|
|||
|
|
only in the specified dimensions.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
:attr:`dim` now accepts tuples of dimensions.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.zeros(2, 1, 2, 1, 2)
|
|||
|
|
>>> x.size()
|
|||
|
|
torch.Size([2, 1, 2, 1, 2])
|
|||
|
|
>>> y = torch.squeeze(x)
|
|||
|
|
>>> y.size()
|
|||
|
|
torch.Size([2, 2, 2])
|
|||
|
|
>>> y = torch.squeeze(x, 0)
|
|||
|
|
>>> y.size()
|
|||
|
|
torch.Size([2, 1, 2, 1, 2])
|
|||
|
|
>>> y = torch.squeeze(x, 1)
|
|||
|
|
>>> y.size()
|
|||
|
|
torch.Size([2, 2, 1, 2])
|
|||
|
|
>>> y = torch.squeeze(x, (1, 2, 3))
|
|||
|
|
torch.Size([2, 2, 2])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def squeeze(input: Tensor, dim: _size) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
squeeze(input, dim=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor with all specified dimensions of :attr:`input` of size `1` removed.
|
|||
|
|
|
|||
|
|
For example, if `input` is of shape:
|
|||
|
|
:math:`(A \times 1 \times B \times C \times 1 \times D)` then the `input.squeeze()`
|
|||
|
|
will be of shape: :math:`(A \times B \times C \times D)`.
|
|||
|
|
|
|||
|
|
When :attr:`dim` is given, a squeeze operation is done only in the given
|
|||
|
|
dimension(s). If `input` is of shape: :math:`(A \times 1 \times B)`,
|
|||
|
|
``squeeze(input, 0)`` leaves the tensor unchanged, but ``squeeze(input, 1)``
|
|||
|
|
will squeeze the tensor to the shape :math:`(A \times B)`.
|
|||
|
|
|
|||
|
|
.. note:: The returned tensor shares the storage with the input tensor,
|
|||
|
|
so changing the contents of one will change the contents of the other.
|
|||
|
|
|
|||
|
|
.. warning:: If the tensor has a batch dimension of size 1, then `squeeze(input)`
|
|||
|
|
will also remove the batch dimension, which can lead to unexpected
|
|||
|
|
errors. Consider specifying only the dims you wish to be squeezed.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints, optional): if given, the input will be squeezed
|
|||
|
|
only in the specified dimensions.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
:attr:`dim` now accepts tuples of dimensions.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.zeros(2, 1, 2, 1, 2)
|
|||
|
|
>>> x.size()
|
|||
|
|
torch.Size([2, 1, 2, 1, 2])
|
|||
|
|
>>> y = torch.squeeze(x)
|
|||
|
|
>>> y.size()
|
|||
|
|
torch.Size([2, 2, 2])
|
|||
|
|
>>> y = torch.squeeze(x, 0)
|
|||
|
|
>>> y.size()
|
|||
|
|
torch.Size([2, 1, 2, 1, 2])
|
|||
|
|
>>> y = torch.squeeze(x, 1)
|
|||
|
|
>>> y.size()
|
|||
|
|
torch.Size([2, 2, 1, 2])
|
|||
|
|
>>> y = torch.squeeze(x, (1, 2, 3))
|
|||
|
|
torch.Size([2, 2, 2])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def squeeze(input: Tensor, dim: Union[str, ellipsis, None]) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
squeeze(input, dim=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor with all specified dimensions of :attr:`input` of size `1` removed.
|
|||
|
|
|
|||
|
|
For example, if `input` is of shape:
|
|||
|
|
:math:`(A \times 1 \times B \times C \times 1 \times D)` then the `input.squeeze()`
|
|||
|
|
will be of shape: :math:`(A \times B \times C \times D)`.
|
|||
|
|
|
|||
|
|
When :attr:`dim` is given, a squeeze operation is done only in the given
|
|||
|
|
dimension(s). If `input` is of shape: :math:`(A \times 1 \times B)`,
|
|||
|
|
``squeeze(input, 0)`` leaves the tensor unchanged, but ``squeeze(input, 1)``
|
|||
|
|
will squeeze the tensor to the shape :math:`(A \times B)`.
|
|||
|
|
|
|||
|
|
.. note:: The returned tensor shares the storage with the input tensor,
|
|||
|
|
so changing the contents of one will change the contents of the other.
|
|||
|
|
|
|||
|
|
.. warning:: If the tensor has a batch dimension of size 1, then `squeeze(input)`
|
|||
|
|
will also remove the batch dimension, which can lead to unexpected
|
|||
|
|
errors. Consider specifying only the dims you wish to be squeezed.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints, optional): if given, the input will be squeezed
|
|||
|
|
only in the specified dimensions.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
:attr:`dim` now accepts tuples of dimensions.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.zeros(2, 1, 2, 1, 2)
|
|||
|
|
>>> x.size()
|
|||
|
|
torch.Size([2, 1, 2, 1, 2])
|
|||
|
|
>>> y = torch.squeeze(x)
|
|||
|
|
>>> y.size()
|
|||
|
|
torch.Size([2, 2, 2])
|
|||
|
|
>>> y = torch.squeeze(x, 0)
|
|||
|
|
>>> y.size()
|
|||
|
|
torch.Size([2, 1, 2, 1, 2])
|
|||
|
|
>>> y = torch.squeeze(x, 1)
|
|||
|
|
>>> y.size()
|
|||
|
|
torch.Size([2, 2, 1, 2])
|
|||
|
|
>>> y = torch.squeeze(x, (1, 2, 3))
|
|||
|
|
torch.Size([2, 2, 2])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def squeeze_copy(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.squeeze`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def squeeze_copy(input: Tensor, dim: _int, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.squeeze`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def squeeze_copy(input: Tensor, dim: _size, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.squeeze`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def sspaddmm(beta: Union[Number, _complex], self: Tensor, alpha: Union[Number, _complex], mat1: Tensor, mat2: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
sspaddmm(input, mat1, mat2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Matrix multiplies a sparse tensor :attr:`mat1` with a dense tensor
|
|||
|
|
:attr:`mat2`, then adds the sparse tensor :attr:`input` to the result.
|
|||
|
|
|
|||
|
|
Note: This function is equivalent to :func:`torch.addmm`, except
|
|||
|
|
:attr:`input` and :attr:`mat1` are sparse.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): a sparse matrix to be added
|
|||
|
|
mat1 (Tensor): a sparse matrix to be matrix multiplied
|
|||
|
|
mat2 (Tensor): a dense matrix to be matrix multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`mat` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`mat1 @ mat2` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def sspaddmm(input: Tensor, mat1: Tensor, mat2: Tensor, *, beta: Union[Number, _complex] = 1, alpha: Union[Number, _complex] = 1, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
sspaddmm(input, mat1, mat2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Matrix multiplies a sparse tensor :attr:`mat1` with a dense tensor
|
|||
|
|
:attr:`mat2`, then adds the sparse tensor :attr:`input` to the result.
|
|||
|
|
|
|||
|
|
Note: This function is equivalent to :func:`torch.addmm`, except
|
|||
|
|
:attr:`input` and :attr:`mat1` are sparse.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): a sparse matrix to be added
|
|||
|
|
mat1 (Tensor): a sparse matrix to be matrix multiplied
|
|||
|
|
mat2 (Tensor): a dense matrix to be matrix multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`mat` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`mat1 @ mat2` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def sspaddmm(beta: Union[Number, _complex], self: Tensor, mat1: Tensor, mat2: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
sspaddmm(input, mat1, mat2, *, beta=1, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Matrix multiplies a sparse tensor :attr:`mat1` with a dense tensor
|
|||
|
|
:attr:`mat2`, then adds the sparse tensor :attr:`input` to the result.
|
|||
|
|
|
|||
|
|
Note: This function is equivalent to :func:`torch.addmm`, except
|
|||
|
|
:attr:`input` and :attr:`mat1` are sparse.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): a sparse matrix to be added
|
|||
|
|
mat1 (Tensor): a sparse matrix to be matrix multiplied
|
|||
|
|
mat2 (Tensor): a dense matrix to be matrix multiplied
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
beta (Number, optional): multiplier for :attr:`mat` (:math:`\beta`)
|
|||
|
|
alpha (Number, optional): multiplier for :math:`mat1 @ mat2` (:math:`\alpha`)
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def stack(tensors: Union[Tuple[Tensor, ...], List[Tensor]], dim: _int = 0, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
stack(tensors, dim=0, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Concatenates a sequence of tensors along a new dimension.
|
|||
|
|
|
|||
|
|
All tensors need to be of the same size.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.cat` concatenates the given sequence along an existing dimension.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
tensors (sequence of Tensors): sequence of tensors to concatenate
|
|||
|
|
dim (int, optional): dimension to insert. Has to be between 0 and the number
|
|||
|
|
of dimensions of concatenated tensors (inclusive). Default: 0
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(2, 3)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 0.3367, 0.1288, 0.2345],
|
|||
|
|
[ 0.2303, -1.1229, -0.1863]])
|
|||
|
|
>>> x = torch.stack((x, x)) # same as torch.stack((x, x), dim=0)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[[ 0.3367, 0.1288, 0.2345],
|
|||
|
|
[ 0.2303, -1.1229, -0.1863]],
|
|||
|
|
|
|||
|
|
[[ 0.3367, 0.1288, 0.2345],
|
|||
|
|
[ 0.2303, -1.1229, -0.1863]]])
|
|||
|
|
>>> x.size()
|
|||
|
|
torch.Size([2, 2, 3])
|
|||
|
|
>>> x = torch.stack((x, x), dim=1)
|
|||
|
|
tensor([[[ 0.3367, 0.1288, 0.2345],
|
|||
|
|
[ 0.3367, 0.1288, 0.2345]],
|
|||
|
|
|
|||
|
|
[[ 0.2303, -1.1229, -0.1863],
|
|||
|
|
[ 0.2303, -1.1229, -0.1863]]])
|
|||
|
|
>>> x = torch.stack((x, x), dim=2)
|
|||
|
|
tensor([[[ 0.3367, 0.3367],
|
|||
|
|
[ 0.1288, 0.1288],
|
|||
|
|
[ 0.2345, 0.2345]],
|
|||
|
|
|
|||
|
|
[[ 0.2303, 0.2303],
|
|||
|
|
[-1.1229, -1.1229],
|
|||
|
|
[-0.1863, -0.1863]]])
|
|||
|
|
>>> x = torch.stack((x, x), dim=-1)
|
|||
|
|
tensor([[[ 0.3367, 0.3367],
|
|||
|
|
[ 0.1288, 0.1288],
|
|||
|
|
[ 0.2345, 0.2345]],
|
|||
|
|
|
|||
|
|
[[ 0.2303, 0.2303],
|
|||
|
|
[-1.1229, -1.1229],
|
|||
|
|
[-0.1863, -0.1863]]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def std(input: Tensor, dim: Optional[Union[_int, _size]], unbiased: _bool = True, keepdim: _bool = False, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
std(input, dim=None, *, correction=1, keepdim=False, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Calculates the standard deviation over the dimensions specified by :attr:`dim`.
|
|||
|
|
:attr:`dim` can be a single dimension, list of dimensions, or ``None`` to
|
|||
|
|
reduce over all dimensions.
|
|||
|
|
|
|||
|
|
The standard deviation (:math:`\sigma`) is calculated as
|
|||
|
|
|
|||
|
|
.. math:: \sigma = \sqrt{\frac{1}{\max(0,~N - \delta N)}\sum_{i=0}^{N-1}(x_i-\bar{x})^2}
|
|||
|
|
|
|||
|
|
where :math:`x` is the sample set of elements, :math:`\bar{x}` is the
|
|||
|
|
sample mean, :math:`N` is the number of samples and :math:`\delta N` is
|
|||
|
|
the :attr:`correction`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints): the dimension or dimensions to reduce.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
correction (int): difference between the sample size and sample degrees of freedom.
|
|||
|
|
Defaults to `Bessel's correction`_, ``correction=1``.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
Previously this argument was called ``unbiased`` and was a boolean
|
|||
|
|
with ``True`` corresponding to ``correction=1`` and ``False`` being
|
|||
|
|
``correction=0``.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor(
|
|||
|
|
... [[ 0.2035, 1.2959, 1.8101, -0.4644],
|
|||
|
|
... [ 1.5027, -0.3270, 0.5905, 0.6538],
|
|||
|
|
... [-1.5745, 1.3330, -0.5596, -0.6548],
|
|||
|
|
... [ 0.1264, -0.5080, 1.6420, 0.1992]])
|
|||
|
|
>>> torch.std(a, dim=1, keepdim=True)
|
|||
|
|
tensor([[1.0311],
|
|||
|
|
[0.7477],
|
|||
|
|
[1.2204],
|
|||
|
|
[0.9087]])
|
|||
|
|
|
|||
|
|
.. _Bessel's correction: https://en.wikipedia.org/wiki/Bessel%27s_correction
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def std(input: Tensor, dim: Optional[Union[_int, _size]] = None, *, correction: Optional[Union[Number, _complex]] = None, keepdim: _bool = False, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
std(input, dim=None, *, correction=1, keepdim=False, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Calculates the standard deviation over the dimensions specified by :attr:`dim`.
|
|||
|
|
:attr:`dim` can be a single dimension, list of dimensions, or ``None`` to
|
|||
|
|
reduce over all dimensions.
|
|||
|
|
|
|||
|
|
The standard deviation (:math:`\sigma`) is calculated as
|
|||
|
|
|
|||
|
|
.. math:: \sigma = \sqrt{\frac{1}{\max(0,~N - \delta N)}\sum_{i=0}^{N-1}(x_i-\bar{x})^2}
|
|||
|
|
|
|||
|
|
where :math:`x` is the sample set of elements, :math:`\bar{x}` is the
|
|||
|
|
sample mean, :math:`N` is the number of samples and :math:`\delta N` is
|
|||
|
|
the :attr:`correction`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints): the dimension or dimensions to reduce.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
correction (int): difference between the sample size and sample degrees of freedom.
|
|||
|
|
Defaults to `Bessel's correction`_, ``correction=1``.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
Previously this argument was called ``unbiased`` and was a boolean
|
|||
|
|
with ``True`` corresponding to ``correction=1`` and ``False`` being
|
|||
|
|
``correction=0``.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor(
|
|||
|
|
... [[ 0.2035, 1.2959, 1.8101, -0.4644],
|
|||
|
|
... [ 1.5027, -0.3270, 0.5905, 0.6538],
|
|||
|
|
... [-1.5745, 1.3330, -0.5596, -0.6548],
|
|||
|
|
... [ 0.1264, -0.5080, 1.6420, 0.1992]])
|
|||
|
|
>>> torch.std(a, dim=1, keepdim=True)
|
|||
|
|
tensor([[1.0311],
|
|||
|
|
[0.7477],
|
|||
|
|
[1.2204],
|
|||
|
|
[0.9087]])
|
|||
|
|
|
|||
|
|
.. _Bessel's correction: https://en.wikipedia.org/wiki/Bessel%27s_correction
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def std(input: Tensor, unbiased: _bool = True) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
std(input, dim=None, *, correction=1, keepdim=False, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Calculates the standard deviation over the dimensions specified by :attr:`dim`.
|
|||
|
|
:attr:`dim` can be a single dimension, list of dimensions, or ``None`` to
|
|||
|
|
reduce over all dimensions.
|
|||
|
|
|
|||
|
|
The standard deviation (:math:`\sigma`) is calculated as
|
|||
|
|
|
|||
|
|
.. math:: \sigma = \sqrt{\frac{1}{\max(0,~N - \delta N)}\sum_{i=0}^{N-1}(x_i-\bar{x})^2}
|
|||
|
|
|
|||
|
|
where :math:`x` is the sample set of elements, :math:`\bar{x}` is the
|
|||
|
|
sample mean, :math:`N` is the number of samples and :math:`\delta N` is
|
|||
|
|
the :attr:`correction`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints): the dimension or dimensions to reduce.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
correction (int): difference between the sample size and sample degrees of freedom.
|
|||
|
|
Defaults to `Bessel's correction`_, ``correction=1``.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
Previously this argument was called ``unbiased`` and was a boolean
|
|||
|
|
with ``True`` corresponding to ``correction=1`` and ``False`` being
|
|||
|
|
``correction=0``.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor(
|
|||
|
|
... [[ 0.2035, 1.2959, 1.8101, -0.4644],
|
|||
|
|
... [ 1.5027, -0.3270, 0.5905, 0.6538],
|
|||
|
|
... [-1.5745, 1.3330, -0.5596, -0.6548],
|
|||
|
|
... [ 0.1264, -0.5080, 1.6420, 0.1992]])
|
|||
|
|
>>> torch.std(a, dim=1, keepdim=True)
|
|||
|
|
tensor([[1.0311],
|
|||
|
|
[0.7477],
|
|||
|
|
[1.2204],
|
|||
|
|
[0.9087]])
|
|||
|
|
|
|||
|
|
.. _Bessel's correction: https://en.wikipedia.org/wiki/Bessel%27s_correction
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def std(input: Tensor, dim: Sequence[Union[str, ellipsis, None]], *, correction: Optional[Union[Number, _complex]] = None, keepdim: _bool = False, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
std(input, dim=None, *, correction=1, keepdim=False, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Calculates the standard deviation over the dimensions specified by :attr:`dim`.
|
|||
|
|
:attr:`dim` can be a single dimension, list of dimensions, or ``None`` to
|
|||
|
|
reduce over all dimensions.
|
|||
|
|
|
|||
|
|
The standard deviation (:math:`\sigma`) is calculated as
|
|||
|
|
|
|||
|
|
.. math:: \sigma = \sqrt{\frac{1}{\max(0,~N - \delta N)}\sum_{i=0}^{N-1}(x_i-\bar{x})^2}
|
|||
|
|
|
|||
|
|
where :math:`x` is the sample set of elements, :math:`\bar{x}` is the
|
|||
|
|
sample mean, :math:`N` is the number of samples and :math:`\delta N` is
|
|||
|
|
the :attr:`correction`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints): the dimension or dimensions to reduce.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
correction (int): difference between the sample size and sample degrees of freedom.
|
|||
|
|
Defaults to `Bessel's correction`_, ``correction=1``.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
Previously this argument was called ``unbiased`` and was a boolean
|
|||
|
|
with ``True`` corresponding to ``correction=1`` and ``False`` being
|
|||
|
|
``correction=0``.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor(
|
|||
|
|
... [[ 0.2035, 1.2959, 1.8101, -0.4644],
|
|||
|
|
... [ 1.5027, -0.3270, 0.5905, 0.6538],
|
|||
|
|
... [-1.5745, 1.3330, -0.5596, -0.6548],
|
|||
|
|
... [ 0.1264, -0.5080, 1.6420, 0.1992]])
|
|||
|
|
>>> torch.std(a, dim=1, keepdim=True)
|
|||
|
|
tensor([[1.0311],
|
|||
|
|
[0.7477],
|
|||
|
|
[1.2204],
|
|||
|
|
[0.9087]])
|
|||
|
|
|
|||
|
|
.. _Bessel's correction: https://en.wikipedia.org/wiki/Bessel%27s_correction
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def std(input: Tensor, dim: Sequence[Union[str, ellipsis, None]], unbiased: _bool = True, keepdim: _bool = False, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
std(input, dim=None, *, correction=1, keepdim=False, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Calculates the standard deviation over the dimensions specified by :attr:`dim`.
|
|||
|
|
:attr:`dim` can be a single dimension, list of dimensions, or ``None`` to
|
|||
|
|
reduce over all dimensions.
|
|||
|
|
|
|||
|
|
The standard deviation (:math:`\sigma`) is calculated as
|
|||
|
|
|
|||
|
|
.. math:: \sigma = \sqrt{\frac{1}{\max(0,~N - \delta N)}\sum_{i=0}^{N-1}(x_i-\bar{x})^2}
|
|||
|
|
|
|||
|
|
where :math:`x` is the sample set of elements, :math:`\bar{x}` is the
|
|||
|
|
sample mean, :math:`N` is the number of samples and :math:`\delta N` is
|
|||
|
|
the :attr:`correction`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int or tuple of ints): the dimension or dimensions to reduce.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
correction (int): difference between the sample size and sample degrees of freedom.
|
|||
|
|
Defaults to `Bessel's correction`_, ``correction=1``.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
Previously this argument was called ``unbiased`` and was a boolean
|
|||
|
|
with ``True`` corresponding to ``correction=1`` and ``False`` being
|
|||
|
|
``correction=0``.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor(
|
|||
|
|
... [[ 0.2035, 1.2959, 1.8101, -0.4644],
|
|||
|
|
... [ 1.5027, -0.3270, 0.5905, 0.6538],
|
|||
|
|
... [-1.5745, 1.3330, -0.5596, -0.6548],
|
|||
|
|
... [ 0.1264, -0.5080, 1.6420, 0.1992]])
|
|||
|
|
>>> torch.std(a, dim=1, keepdim=True)
|
|||
|
|
tensor([[1.0311],
|
|||
|
|
[0.7477],
|
|||
|
|
[1.2204],
|
|||
|
|
[0.9087]])
|
|||
|
|
|
|||
|
|
.. _Bessel's correction: https://en.wikipedia.org/wiki/Bessel%27s_correction
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def std_mean(input: Tensor, dim: Optional[Union[_int, _size]], unbiased: _bool = True, keepdim: _bool = False) -> Tuple[Tensor, Tensor]:
|
|||
|
|
r"""
|
|||
|
|
std_mean(input, dim=None, *, correction=1, keepdim=False, out=None) -> (Tensor, Tensor)
|
|||
|
|
|
|||
|
|
Calculates the standard deviation and mean over the dimensions specified by
|
|||
|
|
:attr:`dim`. :attr:`dim` can be a single dimension, list of dimensions, or
|
|||
|
|
``None`` to reduce over all dimensions.
|
|||
|
|
|
|||
|
|
The standard deviation (:math:`\sigma`) is calculated as
|
|||
|
|
|
|||
|
|
.. math:: \sigma = \sqrt{\frac{1}{\max(0,~N - \delta N)}\sum_{i=0}^{N-1}(x_i-\bar{x})^2}
|
|||
|
|
|
|||
|
|
where :math:`x` is the sample set of elements, :math:`\bar{x}` is the
|
|||
|
|
sample mean, :math:`N` is the number of samples and :math:`\delta N` is
|
|||
|
|
the :attr:`correction`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
dim (int or tuple of ints, optional): the dimension or dimensions to reduce.
|
|||
|
|
If ``None``, all dimensions are reduced.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
correction (int): difference between the sample size and sample degrees of freedom.
|
|||
|
|
Defaults to `Bessel's correction`_, ``correction=1``.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
Previously this argument was called ``unbiased`` and was a boolean
|
|||
|
|
with ``True`` corresponding to ``correction=1`` and ``False`` being
|
|||
|
|
``correction=0``.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A tuple (std, mean) containing the standard deviation and mean.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor(
|
|||
|
|
... [[ 0.2035, 1.2959, 1.8101, -0.4644],
|
|||
|
|
... [ 1.5027, -0.3270, 0.5905, 0.6538],
|
|||
|
|
... [-1.5745, 1.3330, -0.5596, -0.6548],
|
|||
|
|
... [ 0.1264, -0.5080, 1.6420, 0.1992]])
|
|||
|
|
>>> torch.std_mean(a, dim=0, keepdim=True)
|
|||
|
|
(tensor([[1.2620, 1.0028, 1.0957, 0.6038]]),
|
|||
|
|
tensor([[ 0.0645, 0.4485, 0.8707, -0.0665]]))
|
|||
|
|
|
|||
|
|
.. _Bessel's correction: https://en.wikipedia.org/wiki/Bessel%27s_correction
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def std_mean(input: Tensor, dim: Optional[Union[_int, _size]] = None, *, correction: Optional[Union[Number, _complex]] = None, keepdim: _bool = False) -> Tuple[Tensor, Tensor]:
|
|||
|
|
r"""
|
|||
|
|
std_mean(input, dim=None, *, correction=1, keepdim=False, out=None) -> (Tensor, Tensor)
|
|||
|
|
|
|||
|
|
Calculates the standard deviation and mean over the dimensions specified by
|
|||
|
|
:attr:`dim`. :attr:`dim` can be a single dimension, list of dimensions, or
|
|||
|
|
``None`` to reduce over all dimensions.
|
|||
|
|
|
|||
|
|
The standard deviation (:math:`\sigma`) is calculated as
|
|||
|
|
|
|||
|
|
.. math:: \sigma = \sqrt{\frac{1}{\max(0,~N - \delta N)}\sum_{i=0}^{N-1}(x_i-\bar{x})^2}
|
|||
|
|
|
|||
|
|
where :math:`x` is the sample set of elements, :math:`\bar{x}` is the
|
|||
|
|
sample mean, :math:`N` is the number of samples and :math:`\delta N` is
|
|||
|
|
the :attr:`correction`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
dim (int or tuple of ints, optional): the dimension or dimensions to reduce.
|
|||
|
|
If ``None``, all dimensions are reduced.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
correction (int): difference between the sample size and sample degrees of freedom.
|
|||
|
|
Defaults to `Bessel's correction`_, ``correction=1``.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
Previously this argument was called ``unbiased`` and was a boolean
|
|||
|
|
with ``True`` corresponding to ``correction=1`` and ``False`` being
|
|||
|
|
``correction=0``.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A tuple (std, mean) containing the standard deviation and mean.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor(
|
|||
|
|
... [[ 0.2035, 1.2959, 1.8101, -0.4644],
|
|||
|
|
... [ 1.5027, -0.3270, 0.5905, 0.6538],
|
|||
|
|
... [-1.5745, 1.3330, -0.5596, -0.6548],
|
|||
|
|
... [ 0.1264, -0.5080, 1.6420, 0.1992]])
|
|||
|
|
>>> torch.std_mean(a, dim=0, keepdim=True)
|
|||
|
|
(tensor([[1.2620, 1.0028, 1.0957, 0.6038]]),
|
|||
|
|
tensor([[ 0.0645, 0.4485, 0.8707, -0.0665]]))
|
|||
|
|
|
|||
|
|
.. _Bessel's correction: https://en.wikipedia.org/wiki/Bessel%27s_correction
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def std_mean(input: Tensor, unbiased: _bool = True) -> Tuple[Tensor, Tensor]:
|
|||
|
|
r"""
|
|||
|
|
std_mean(input, dim=None, *, correction=1, keepdim=False, out=None) -> (Tensor, Tensor)
|
|||
|
|
|
|||
|
|
Calculates the standard deviation and mean over the dimensions specified by
|
|||
|
|
:attr:`dim`. :attr:`dim` can be a single dimension, list of dimensions, or
|
|||
|
|
``None`` to reduce over all dimensions.
|
|||
|
|
|
|||
|
|
The standard deviation (:math:`\sigma`) is calculated as
|
|||
|
|
|
|||
|
|
.. math:: \sigma = \sqrt{\frac{1}{\max(0,~N - \delta N)}\sum_{i=0}^{N-1}(x_i-\bar{x})^2}
|
|||
|
|
|
|||
|
|
where :math:`x` is the sample set of elements, :math:`\bar{x}` is the
|
|||
|
|
sample mean, :math:`N` is the number of samples and :math:`\delta N` is
|
|||
|
|
the :attr:`correction`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
dim (int or tuple of ints, optional): the dimension or dimensions to reduce.
|
|||
|
|
If ``None``, all dimensions are reduced.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
correction (int): difference between the sample size and sample degrees of freedom.
|
|||
|
|
Defaults to `Bessel's correction`_, ``correction=1``.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
Previously this argument was called ``unbiased`` and was a boolean
|
|||
|
|
with ``True`` corresponding to ``correction=1`` and ``False`` being
|
|||
|
|
``correction=0``.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A tuple (std, mean) containing the standard deviation and mean.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor(
|
|||
|
|
... [[ 0.2035, 1.2959, 1.8101, -0.4644],
|
|||
|
|
... [ 1.5027, -0.3270, 0.5905, 0.6538],
|
|||
|
|
... [-1.5745, 1.3330, -0.5596, -0.6548],
|
|||
|
|
... [ 0.1264, -0.5080, 1.6420, 0.1992]])
|
|||
|
|
>>> torch.std_mean(a, dim=0, keepdim=True)
|
|||
|
|
(tensor([[1.2620, 1.0028, 1.0957, 0.6038]]),
|
|||
|
|
tensor([[ 0.0645, 0.4485, 0.8707, -0.0665]]))
|
|||
|
|
|
|||
|
|
.. _Bessel's correction: https://en.wikipedia.org/wiki/Bessel%27s_correction
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def std_mean(input: Tensor, dim: Sequence[Union[str, ellipsis, None]], *, correction: Optional[Union[Number, _complex]] = None, keepdim: _bool = False) -> Tuple[Tensor, Tensor]:
|
|||
|
|
r"""
|
|||
|
|
std_mean(input, dim=None, *, correction=1, keepdim=False, out=None) -> (Tensor, Tensor)
|
|||
|
|
|
|||
|
|
Calculates the standard deviation and mean over the dimensions specified by
|
|||
|
|
:attr:`dim`. :attr:`dim` can be a single dimension, list of dimensions, or
|
|||
|
|
``None`` to reduce over all dimensions.
|
|||
|
|
|
|||
|
|
The standard deviation (:math:`\sigma`) is calculated as
|
|||
|
|
|
|||
|
|
.. math:: \sigma = \sqrt{\frac{1}{\max(0,~N - \delta N)}\sum_{i=0}^{N-1}(x_i-\bar{x})^2}
|
|||
|
|
|
|||
|
|
where :math:`x` is the sample set of elements, :math:`\bar{x}` is the
|
|||
|
|
sample mean, :math:`N` is the number of samples and :math:`\delta N` is
|
|||
|
|
the :attr:`correction`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
dim (int or tuple of ints, optional): the dimension or dimensions to reduce.
|
|||
|
|
If ``None``, all dimensions are reduced.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
correction (int): difference between the sample size and sample degrees of freedom.
|
|||
|
|
Defaults to `Bessel's correction`_, ``correction=1``.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
Previously this argument was called ``unbiased`` and was a boolean
|
|||
|
|
with ``True`` corresponding to ``correction=1`` and ``False`` being
|
|||
|
|
``correction=0``.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A tuple (std, mean) containing the standard deviation and mean.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor(
|
|||
|
|
... [[ 0.2035, 1.2959, 1.8101, -0.4644],
|
|||
|
|
... [ 1.5027, -0.3270, 0.5905, 0.6538],
|
|||
|
|
... [-1.5745, 1.3330, -0.5596, -0.6548],
|
|||
|
|
... [ 0.1264, -0.5080, 1.6420, 0.1992]])
|
|||
|
|
>>> torch.std_mean(a, dim=0, keepdim=True)
|
|||
|
|
(tensor([[1.2620, 1.0028, 1.0957, 0.6038]]),
|
|||
|
|
tensor([[ 0.0645, 0.4485, 0.8707, -0.0665]]))
|
|||
|
|
|
|||
|
|
.. _Bessel's correction: https://en.wikipedia.org/wiki/Bessel%27s_correction
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def std_mean(input: Tensor, dim: Sequence[Union[str, ellipsis, None]], unbiased: _bool = True, keepdim: _bool = False) -> Tuple[Tensor, Tensor]:
|
|||
|
|
r"""
|
|||
|
|
std_mean(input, dim=None, *, correction=1, keepdim=False, out=None) -> (Tensor, Tensor)
|
|||
|
|
|
|||
|
|
Calculates the standard deviation and mean over the dimensions specified by
|
|||
|
|
:attr:`dim`. :attr:`dim` can be a single dimension, list of dimensions, or
|
|||
|
|
``None`` to reduce over all dimensions.
|
|||
|
|
|
|||
|
|
The standard deviation (:math:`\sigma`) is calculated as
|
|||
|
|
|
|||
|
|
.. math:: \sigma = \sqrt{\frac{1}{\max(0,~N - \delta N)}\sum_{i=0}^{N-1}(x_i-\bar{x})^2}
|
|||
|
|
|
|||
|
|
where :math:`x` is the sample set of elements, :math:`\bar{x}` is the
|
|||
|
|
sample mean, :math:`N` is the number of samples and :math:`\delta N` is
|
|||
|
|
the :attr:`correction`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
dim (int or tuple of ints, optional): the dimension or dimensions to reduce.
|
|||
|
|
If ``None``, all dimensions are reduced.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
correction (int): difference between the sample size and sample degrees of freedom.
|
|||
|
|
Defaults to `Bessel's correction`_, ``correction=1``.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
Previously this argument was called ``unbiased`` and was a boolean
|
|||
|
|
with ``True`` corresponding to ``correction=1`` and ``False`` being
|
|||
|
|
``correction=0``.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A tuple (std, mean) containing the standard deviation and mean.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor(
|
|||
|
|
... [[ 0.2035, 1.2959, 1.8101, -0.4644],
|
|||
|
|
... [ 1.5027, -0.3270, 0.5905, 0.6538],
|
|||
|
|
... [-1.5745, 1.3330, -0.5596, -0.6548],
|
|||
|
|
... [ 0.1264, -0.5080, 1.6420, 0.1992]])
|
|||
|
|
>>> torch.std_mean(a, dim=0, keepdim=True)
|
|||
|
|
(tensor([[1.2620, 1.0028, 1.0957, 0.6038]]),
|
|||
|
|
tensor([[ 0.0645, 0.4485, 0.8707, -0.0665]]))
|
|||
|
|
|
|||
|
|
.. _Bessel's correction: https://en.wikipedia.org/wiki/Bessel%27s_correction
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def sub(input: Union[Tensor, Number, _complex], other: Union[Tensor, Number, _complex], *, alpha: Optional[Union[Number, _complex]] = 1, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
sub(input, other, *, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Subtracts :attr:`other`, scaled by :attr:`alpha`, from :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{{out}}_i = \text{{input}}_i - \text{{alpha}} \times \text{{other}}_i
|
|||
|
|
|
|||
|
|
|
|||
|
|
Supports :ref:`broadcasting to a common shape <broadcasting-semantics>`,
|
|||
|
|
:ref:`type promotion <type-promotion-doc>`, and integer, float, and complex inputs.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
other (Tensor or Number): the tensor or number to subtract from :attr:`input`.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
alpha (Number): the multiplier for :attr:`other`.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor((1, 2))
|
|||
|
|
>>> b = torch.tensor((0, 1))
|
|||
|
|
>>> torch.sub(a, b, alpha=2)
|
|||
|
|
tensor([1, 0])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def sub(self: Tensor, alpha: Union[Number, _complex], other: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
sub(input, other, *, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Subtracts :attr:`other`, scaled by :attr:`alpha`, from :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{{out}}_i = \text{{input}}_i - \text{{alpha}} \times \text{{other}}_i
|
|||
|
|
|
|||
|
|
|
|||
|
|
Supports :ref:`broadcasting to a common shape <broadcasting-semantics>`,
|
|||
|
|
:ref:`type promotion <type-promotion-doc>`, and integer, float, and complex inputs.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
other (Tensor or Number): the tensor or number to subtract from :attr:`input`.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
alpha (Number): the multiplier for :attr:`other`.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor((1, 2))
|
|||
|
|
>>> b = torch.tensor((0, 1))
|
|||
|
|
>>> torch.sub(a, b, alpha=2)
|
|||
|
|
tensor([1, 0])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def sub(self: Tensor, alpha: Union[Number, _complex], other: Tensor, *, out: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
sub(input, other, *, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Subtracts :attr:`other`, scaled by :attr:`alpha`, from :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{{out}}_i = \text{{input}}_i - \text{{alpha}} \times \text{{other}}_i
|
|||
|
|
|
|||
|
|
|
|||
|
|
Supports :ref:`broadcasting to a common shape <broadcasting-semantics>`,
|
|||
|
|
:ref:`type promotion <type-promotion-doc>`, and integer, float, and complex inputs.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
other (Tensor or Number): the tensor or number to subtract from :attr:`input`.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
alpha (Number): the multiplier for :attr:`other`.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor((1, 2))
|
|||
|
|
>>> b = torch.tensor((0, 1))
|
|||
|
|
>>> torch.sub(a, b, alpha=2)
|
|||
|
|
tensor([1, 0])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def subtract(input: Tensor, other: Tensor, *, alpha: Union[Number, _complex] = 1, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
subtract(input, other, *, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.sub`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def subtract(input: Tensor, other: Union[Number, _complex], alpha: Union[Number, _complex] = 1) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
subtract(input, other, *, alpha=1, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.sub`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def sum(input: Tensor, *, dtype: Optional[_dtype] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
sum(input, *, dtype=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the sum of all elements in the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(1, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.1133, -0.9567, 0.2958]])
|
|||
|
|
>>> torch.sum(a)
|
|||
|
|
tensor(-0.5475)
|
|||
|
|
|
|||
|
|
.. function:: sum(input, dim, keepdim=False, *, dtype=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns the sum of each row of the :attr:`input` tensor in the given
|
|||
|
|
dimension :attr:`dim`. If :attr:`dim` is a list of dimensions,
|
|||
|
|
reduce over all of them.
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
dim (int or tuple of ints, optional): the dimension or dimensions to reduce.
|
|||
|
|
If ``None``, all dimensions are reduced.
|
|||
|
|
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.0569, -0.2475, 0.0737, -0.3429],
|
|||
|
|
[-0.2993, 0.9138, 0.9337, -1.6864],
|
|||
|
|
[ 0.1132, 0.7892, -0.1003, 0.5688],
|
|||
|
|
[ 0.3637, -0.9906, -0.4752, -1.5197]])
|
|||
|
|
>>> torch.sum(a, 1)
|
|||
|
|
tensor([-0.4598, -0.1381, 1.3708, -2.6217])
|
|||
|
|
>>> b = torch.arange(4 * 5 * 6).view(4, 5, 6)
|
|||
|
|
>>> torch.sum(b, (2, 1))
|
|||
|
|
tensor([ 435., 1335., 2235., 3135.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def sum(input: Tensor, dim: Optional[Union[_int, _size]], keepdim: _bool = False, *, dtype: Optional[_dtype] = None, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
sum(input, *, dtype=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the sum of all elements in the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(1, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.1133, -0.9567, 0.2958]])
|
|||
|
|
>>> torch.sum(a)
|
|||
|
|
tensor(-0.5475)
|
|||
|
|
|
|||
|
|
.. function:: sum(input, dim, keepdim=False, *, dtype=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns the sum of each row of the :attr:`input` tensor in the given
|
|||
|
|
dimension :attr:`dim`. If :attr:`dim` is a list of dimensions,
|
|||
|
|
reduce over all of them.
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
dim (int or tuple of ints, optional): the dimension or dimensions to reduce.
|
|||
|
|
If ``None``, all dimensions are reduced.
|
|||
|
|
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.0569, -0.2475, 0.0737, -0.3429],
|
|||
|
|
[-0.2993, 0.9138, 0.9337, -1.6864],
|
|||
|
|
[ 0.1132, 0.7892, -0.1003, 0.5688],
|
|||
|
|
[ 0.3637, -0.9906, -0.4752, -1.5197]])
|
|||
|
|
>>> torch.sum(a, 1)
|
|||
|
|
tensor([-0.4598, -0.1381, 1.3708, -2.6217])
|
|||
|
|
>>> b = torch.arange(4 * 5 * 6).view(4, 5, 6)
|
|||
|
|
>>> torch.sum(b, (2, 1))
|
|||
|
|
tensor([ 435., 1335., 2235., 3135.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def sum(input: Tensor, dim: Sequence[Union[str, ellipsis, None]], keepdim: _bool = False, *, dtype: Optional[_dtype] = None, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
sum(input, *, dtype=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the sum of all elements in the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(1, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.1133, -0.9567, 0.2958]])
|
|||
|
|
>>> torch.sum(a)
|
|||
|
|
tensor(-0.5475)
|
|||
|
|
|
|||
|
|
.. function:: sum(input, dim, keepdim=False, *, dtype=None) -> Tensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
Returns the sum of each row of the :attr:`input` tensor in the given
|
|||
|
|
dimension :attr:`dim`. If :attr:`dim` is a list of dimensions,
|
|||
|
|
reduce over all of them.
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
dim (int or tuple of ints, optional): the dimension or dimensions to reduce.
|
|||
|
|
If ``None``, all dimensions are reduced.
|
|||
|
|
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
If specified, the input tensor is casted to :attr:`dtype` before the operation
|
|||
|
|
is performed. This is useful for preventing data type overflows. Default: None.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4, 4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.0569, -0.2475, 0.0737, -0.3429],
|
|||
|
|
[-0.2993, 0.9138, 0.9337, -1.6864],
|
|||
|
|
[ 0.1132, 0.7892, -0.1003, 0.5688],
|
|||
|
|
[ 0.3637, -0.9906, -0.4752, -1.5197]])
|
|||
|
|
>>> torch.sum(a, 1)
|
|||
|
|
tensor([-0.4598, -0.1381, 1.3708, -2.6217])
|
|||
|
|
>>> b = torch.arange(4 * 5 * 6).view(4, 5, 6)
|
|||
|
|
>>> torch.sum(b, (2, 1))
|
|||
|
|
tensor([ 435., 1335., 2235., 3135.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def svd(input: Tensor, some: _bool = True, compute_uv: _bool = True, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.svd:
|
|||
|
|
r"""
|
|||
|
|
svd(input, some=True, compute_uv=True, *, out=None) -> (Tensor, Tensor, Tensor)
|
|||
|
|
|
|||
|
|
Computes the singular value decomposition of either a matrix or batch of
|
|||
|
|
matrices :attr:`input`. The singular value decomposition is represented as a
|
|||
|
|
namedtuple `(U, S, V)`, such that :attr:`input` :math:`= U \text{diag}(S) V^{\text{H}}`.
|
|||
|
|
where :math:`V^{\text{H}}` is the transpose of `V` for real inputs,
|
|||
|
|
and the conjugate transpose of `V` for complex inputs.
|
|||
|
|
If :attr:`input` is a batch of matrices, then `U`, `S`, and `V` are also
|
|||
|
|
batched with the same batch dimensions as :attr:`input`.
|
|||
|
|
|
|||
|
|
If :attr:`some` is `True` (default), the method returns the reduced singular
|
|||
|
|
value decomposition. In this case, if the last two dimensions of :attr:`input` are
|
|||
|
|
`m` and `n`, then the returned `U` and `V` matrices will contain only
|
|||
|
|
`min(n, m)` orthonormal columns.
|
|||
|
|
|
|||
|
|
If :attr:`compute_uv` is `False`, the returned `U` and `V` will be
|
|||
|
|
zero-filled matrices of shape `(m, m)` and `(n, n)`
|
|||
|
|
respectively, and the same device as :attr:`input`. The argument :attr:`some`
|
|||
|
|
has no effect when :attr:`compute_uv` is `False`.
|
|||
|
|
|
|||
|
|
Supports :attr:`input` of float, double, cfloat and cdouble data types.
|
|||
|
|
The dtypes of `U` and `V` are the same as :attr:`input`'s. `S` will
|
|||
|
|
always be real-valued, even if :attr:`input` is complex.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
|
|||
|
|
:func:`torch.svd` is deprecated in favor of :func:`torch.linalg.svd`
|
|||
|
|
and will be removed in a future PyTorch release.
|
|||
|
|
|
|||
|
|
``U, S, V = torch.svd(A, some=some, compute_uv=True)`` (default) should be replaced with
|
|||
|
|
|
|||
|
|
.. code:: python
|
|||
|
|
|
|||
|
|
U, S, Vh = torch.linalg.svd(A, full_matrices=not some)
|
|||
|
|
V = Vh.mH
|
|||
|
|
|
|||
|
|
``_, S, _ = torch.svd(A, some=some, compute_uv=False)`` should be replaced with
|
|||
|
|
|
|||
|
|
.. code:: python
|
|||
|
|
|
|||
|
|
S = torch.linalg.svdvals(A)
|
|||
|
|
|
|||
|
|
.. note:: Differences with :func:`torch.linalg.svd`:
|
|||
|
|
|
|||
|
|
* :attr:`some` is the opposite of
|
|||
|
|
:func:`torch.linalg.svd`'s :attr:`full_matrices`. Note that
|
|||
|
|
default value for both is `True`, so the default behavior is
|
|||
|
|
effectively the opposite.
|
|||
|
|
* :func:`torch.svd` returns `V`, whereas :func:`torch.linalg.svd` returns
|
|||
|
|
`Vh`, that is, :math:`V^{\text{H}}`.
|
|||
|
|
* If :attr:`compute_uv` is `False`, :func:`torch.svd` returns zero-filled
|
|||
|
|
tensors for `U` and `Vh`, whereas :func:`torch.linalg.svd` returns
|
|||
|
|
empty tensors.
|
|||
|
|
|
|||
|
|
.. note:: The singular values are returned in descending order. If :attr:`input` is a batch of matrices,
|
|||
|
|
then the singular values of each matrix in the batch are returned in descending order.
|
|||
|
|
|
|||
|
|
.. note:: The `S` tensor can only be used to compute gradients if :attr:`compute_uv` is `True`.
|
|||
|
|
|
|||
|
|
.. note:: When :attr:`some` is `False`, the gradients on `U[..., :, min(m, n):]`
|
|||
|
|
and `V[..., :, min(m, n):]` will be ignored in the backward pass, as those vectors
|
|||
|
|
can be arbitrary bases of the corresponding subspaces.
|
|||
|
|
|
|||
|
|
.. note:: The implementation of :func:`torch.linalg.svd` on CPU uses LAPACK's routine `?gesdd`
|
|||
|
|
(a divide-and-conquer algorithm) instead of `?gesvd` for speed. Analogously,
|
|||
|
|
on GPU, it uses cuSOLVER's routines `gesvdj` and `gesvdjBatched` on CUDA 10.1.243
|
|||
|
|
and later, and MAGMA's routine `gesdd` on earlier versions of CUDA.
|
|||
|
|
|
|||
|
|
.. note:: The returned `U` will not be contiguous. The matrix (or batch of matrices) will
|
|||
|
|
be represented as a column-major matrix (i.e. Fortran-contiguous).
|
|||
|
|
|
|||
|
|
.. warning:: The gradients with respect to `U` and `V` will only be finite when the input does not
|
|||
|
|
have zero nor repeated singular values.
|
|||
|
|
|
|||
|
|
.. warning:: If the distance between any two singular values is close to zero, the gradients with respect to
|
|||
|
|
`U` and `V` will be numerically unstable, as they depends on
|
|||
|
|
:math:`\frac{1}{\min_{i \neq j} \sigma_i^2 - \sigma_j^2}`. The same happens when the matrix
|
|||
|
|
has small singular values, as these gradients also depend on `S^{-1}`.
|
|||
|
|
|
|||
|
|
.. warning:: For complex-valued :attr:`input` the singular value decomposition is not unique,
|
|||
|
|
as `U` and `V` may be multiplied by an arbitrary phase factor :math:`e^{i \phi}` on every column.
|
|||
|
|
The same happens when :attr:`input` has repeated singular values, where one may multiply
|
|||
|
|
the columns of the spanning subspace in `U` and `V` by a rotation matrix
|
|||
|
|
and `the resulting vectors will span the same subspace`_.
|
|||
|
|
Different platforms, like NumPy, or inputs on different device types,
|
|||
|
|
may produce different `U` and `V` tensors.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor of size `(*, m, n)` where `*` is zero or more
|
|||
|
|
batch dimensions consisting of `(m, n)` matrices.
|
|||
|
|
some (bool, optional): controls whether to compute the reduced or full decomposition, and
|
|||
|
|
consequently, the shape of returned `U` and `V`. Default: `True`.
|
|||
|
|
compute_uv (bool, optional): controls whether to compute `U` and `V`. Default: `True`.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the output tuple of tensors
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(5, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.2364, -0.7752, 0.6372],
|
|||
|
|
[ 1.7201, 0.7394, -0.0504],
|
|||
|
|
[-0.3371, -1.0584, 0.5296],
|
|||
|
|
[ 0.3550, -0.4022, 1.5569],
|
|||
|
|
[ 0.2445, -0.0158, 1.1414]])
|
|||
|
|
>>> u, s, v = torch.svd(a)
|
|||
|
|
>>> u
|
|||
|
|
tensor([[ 0.4027, 0.0287, 0.5434],
|
|||
|
|
[-0.1946, 0.8833, 0.3679],
|
|||
|
|
[ 0.4296, -0.2890, 0.5261],
|
|||
|
|
[ 0.6604, 0.2717, -0.2618],
|
|||
|
|
[ 0.4234, 0.2481, -0.4733]])
|
|||
|
|
>>> s
|
|||
|
|
tensor([2.3289, 2.0315, 0.7806])
|
|||
|
|
>>> v
|
|||
|
|
tensor([[-0.0199, 0.8766, 0.4809],
|
|||
|
|
[-0.5080, 0.4054, -0.7600],
|
|||
|
|
[ 0.8611, 0.2594, -0.4373]])
|
|||
|
|
>>> torch.dist(a, torch.mm(torch.mm(u, torch.diag(s)), v.t()))
|
|||
|
|
tensor(8.6531e-07)
|
|||
|
|
>>> a_big = torch.randn(7, 5, 3)
|
|||
|
|
>>> u, s, v = torch.svd(a_big)
|
|||
|
|
>>> torch.dist(a_big, torch.matmul(torch.matmul(u, torch.diag_embed(s)), v.mT))
|
|||
|
|
tensor(2.6503e-06)
|
|||
|
|
|
|||
|
|
.. _the resulting vectors will span the same subspace:
|
|||
|
|
(https://en.wikipedia.org/wiki/Singular_value_decomposition#Singular_values,_singular_vectors,_and_their_relation_to_the_SVD)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def swapaxes(input: Tensor, axis0: _int, axis1: _int) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
swapaxes(input, axis0, axis1) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.transpose`.
|
|||
|
|
|
|||
|
|
This function is equivalent to NumPy's swapaxes function.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> x = torch.tensor([[[0,1],[2,3]],[[4,5],[6,7]]])
|
|||
|
|
>>> x
|
|||
|
|
tensor([[[0, 1],
|
|||
|
|
[2, 3]],
|
|||
|
|
|
|||
|
|
[[4, 5],
|
|||
|
|
[6, 7]]])
|
|||
|
|
>>> torch.swapaxes(x, 0, 1)
|
|||
|
|
tensor([[[0, 1],
|
|||
|
|
[4, 5]],
|
|||
|
|
|
|||
|
|
[[2, 3],
|
|||
|
|
[6, 7]]])
|
|||
|
|
>>> torch.swapaxes(x, 0, 2)
|
|||
|
|
tensor([[[0, 4],
|
|||
|
|
[2, 6]],
|
|||
|
|
|
|||
|
|
[[1, 5],
|
|||
|
|
[3, 7]]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def swapdims(input: Tensor, dim0: _int, dim1: _int) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
swapdims(input, dim0, dim1) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.transpose`.
|
|||
|
|
|
|||
|
|
This function is equivalent to NumPy's swapaxes function.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> x = torch.tensor([[[0,1],[2,3]],[[4,5],[6,7]]])
|
|||
|
|
>>> x
|
|||
|
|
tensor([[[0, 1],
|
|||
|
|
[2, 3]],
|
|||
|
|
|
|||
|
|
[[4, 5],
|
|||
|
|
[6, 7]]])
|
|||
|
|
>>> torch.swapdims(x, 0, 1)
|
|||
|
|
tensor([[[0, 1],
|
|||
|
|
[4, 5]],
|
|||
|
|
|
|||
|
|
[[2, 3],
|
|||
|
|
[6, 7]]])
|
|||
|
|
>>> torch.swapdims(x, 0, 2)
|
|||
|
|
tensor([[[0, 4],
|
|||
|
|
[2, 6]],
|
|||
|
|
|
|||
|
|
[[1, 5],
|
|||
|
|
[3, 7]]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def sym_constrain_range(size: Union[Number, _complex], *, min: Optional[_int] = None, max: Optional[_int] = None) -> None: ...
|
|||
|
|
def sym_constrain_range_for_size(size: Union[Number, _complex], *, min: Optional[_int] = None, max: Optional[_int] = None) -> None: ...
|
|||
|
|
def t(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
t(input) -> Tensor
|
|||
|
|
|
|||
|
|
Expects :attr:`input` to be <= 2-D tensor and transposes dimensions 0
|
|||
|
|
and 1.
|
|||
|
|
|
|||
|
|
0-D and 1-D tensors are returned as is. When input is a 2-D tensor this
|
|||
|
|
is equivalent to ``transpose(input, 0, 1)``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(())
|
|||
|
|
>>> x
|
|||
|
|
tensor(0.1995)
|
|||
|
|
>>> torch.t(x)
|
|||
|
|
tensor(0.1995)
|
|||
|
|
>>> x = torch.randn(3)
|
|||
|
|
>>> x
|
|||
|
|
tensor([ 2.4320, -0.4608, 0.7702])
|
|||
|
|
>>> torch.t(x)
|
|||
|
|
tensor([ 2.4320, -0.4608, 0.7702])
|
|||
|
|
>>> x = torch.randn(2, 3)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 0.4875, 0.9158, -0.5872],
|
|||
|
|
[ 0.3938, -0.6929, 0.6932]])
|
|||
|
|
>>> torch.t(x)
|
|||
|
|
tensor([[ 0.4875, 0.3938],
|
|||
|
|
[ 0.9158, -0.6929],
|
|||
|
|
[-0.5872, 0.6932]])
|
|||
|
|
|
|||
|
|
See also :func:`torch.transpose`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def t_copy(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.t`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def take(input: Tensor, index: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
take(input, index) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the elements of :attr:`input` at the given indices.
|
|||
|
|
The input tensor is treated as if it were viewed as a 1-D tensor. The result
|
|||
|
|
takes the same shape as the indices.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
index (LongTensor): the indices into tensor
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> src = torch.tensor([[4, 3, 5],
|
|||
|
|
... [6, 7, 8]])
|
|||
|
|
>>> torch.take(src, torch.tensor([0, 2, 5]))
|
|||
|
|
tensor([ 4, 5, 8])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def take_along_dim(input: Tensor, indices: Tensor, dim: Optional[_int] = None, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
take_along_dim(input, indices, dim=None, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Selects values from :attr:`input` at the 1-dimensional indices from :attr:`indices` along the given :attr:`dim`.
|
|||
|
|
|
|||
|
|
If :attr:`dim` is None, the input array is treated as if it has been flattened to 1d.
|
|||
|
|
|
|||
|
|
Functions that return indices along a dimension, like :func:`torch.argmax` and :func:`torch.argsort`,
|
|||
|
|
are designed to work with this function. See the examples below.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
This function is similar to NumPy's `take_along_axis`.
|
|||
|
|
See also :func:`torch.gather`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
indices (tensor): the indices into :attr:`input`. Must have long dtype.
|
|||
|
|
dim (int, optional): dimension to select along.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> t = torch.tensor([[10, 30, 20], [60, 40, 50]])
|
|||
|
|
>>> max_idx = torch.argmax(t)
|
|||
|
|
>>> torch.take_along_dim(t, max_idx)
|
|||
|
|
tensor([60])
|
|||
|
|
>>> sorted_idx = torch.argsort(t, dim=1)
|
|||
|
|
>>> torch.take_along_dim(t, sorted_idx, dim=1)
|
|||
|
|
tensor([[10, 20, 30],
|
|||
|
|
[40, 50, 60]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def tan(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
tan(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the tangent of the elements of :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \tan(\text{input}_{i})
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([-1.2027, -1.7687, 0.4412, -1.3856])
|
|||
|
|
>>> torch.tan(a)
|
|||
|
|
tensor([-2.5930, 4.9859, 0.4722, -5.3366])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def tan_(input: Tensor) -> Tensor: ...
|
|||
|
|
def tanh(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
tanh(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the hyperbolic tangent of the elements
|
|||
|
|
of :attr:`input`.
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_{i} = \tanh(\text{input}_{i})
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 0.8986, -0.7279, 1.1745, 0.2611])
|
|||
|
|
>>> torch.tanh(a)
|
|||
|
|
tensor([ 0.7156, -0.6218, 0.8257, 0.2553])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def tanh_(input: Tensor) -> Tensor: ...
|
|||
|
|
def tensor(data: Any, dtype: Optional[_dtype] = None, device: Optional[DeviceLikeType] = None, requires_grad: _bool = False, pin_memory: _bool = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
tensor(data, *, dtype=None, device=None, requires_grad=False, pin_memory=False) -> Tensor
|
|||
|
|
|
|||
|
|
Constructs a tensor with no autograd history (also known as a "leaf tensor", see :doc:`/notes/autograd`) by copying :attr:`data`.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
|
|||
|
|
When working with tensors prefer using :func:`torch.Tensor.clone`,
|
|||
|
|
:func:`torch.Tensor.detach`, and :func:`torch.Tensor.requires_grad_` for
|
|||
|
|
readability. Letting `t` be a tensor, ``torch.tensor(t)`` is equivalent to
|
|||
|
|
``t.clone().detach()``, and ``torch.tensor(t, requires_grad=True)``
|
|||
|
|
is equivalent to ``t.clone().detach().requires_grad_(True)``.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.as_tensor` preserves autograd history and avoids copies where possible.
|
|||
|
|
:func:`torch.from_numpy` creates a tensor that shares storage with a NumPy array.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
data (array_like): Initial data for the tensor. Can be a list, tuple,
|
|||
|
|
NumPy ``ndarray``, scalar, and other types.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, infers data type from :attr:`data`.
|
|||
|
|
device (:class:`torch.device`, optional): the device of the constructed tensor. If None and data is a tensor
|
|||
|
|
then the device of data is used. If None and data is not a tensor then
|
|||
|
|
the result tensor is constructed on the current device.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
pin_memory (bool, optional): If set, returned tensor would be allocated in
|
|||
|
|
the pinned memory. Works only for CPU tensors. Default: ``False``.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.tensor([[0.1, 1.2], [2.2, 3.1], [4.9, 5.2]])
|
|||
|
|
tensor([[ 0.1000, 1.2000],
|
|||
|
|
[ 2.2000, 3.1000],
|
|||
|
|
[ 4.9000, 5.2000]])
|
|||
|
|
|
|||
|
|
>>> torch.tensor([0, 1]) # Type inference on data
|
|||
|
|
tensor([ 0, 1])
|
|||
|
|
|
|||
|
|
>>> torch.tensor([[0.11111, 0.222222, 0.3333333]],
|
|||
|
|
... dtype=torch.float64,
|
|||
|
|
... device=torch.device('cuda:0')) # creates a double tensor on a CUDA device
|
|||
|
|
tensor([[ 0.1111, 0.2222, 0.3333]], dtype=torch.float64, device='cuda:0')
|
|||
|
|
|
|||
|
|
>>> torch.tensor(3.14159) # Create a zero-dimensional (scalar) tensor
|
|||
|
|
tensor(3.1416)
|
|||
|
|
|
|||
|
|
>>> torch.tensor([]) # Create an empty tensor (of size (0,))
|
|||
|
|
tensor([])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def tensor_split(input: Tensor, tensor_indices_or_sections: Tensor, dim: _int = 0) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
tensor_split(input, indices_or_sections, dim=0) -> List of Tensors
|
|||
|
|
|
|||
|
|
Splits a tensor into multiple sub-tensors, all of which are views of :attr:`input`,
|
|||
|
|
along dimension :attr:`dim` according to the indices or number of sections specified
|
|||
|
|
by :attr:`indices_or_sections`. This function is based on NumPy's
|
|||
|
|
:func:`numpy.array_split`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to split
|
|||
|
|
indices_or_sections (Tensor, int or list or tuple of ints):
|
|||
|
|
If :attr:`indices_or_sections` is an integer ``n`` or a zero dimensional long tensor
|
|||
|
|
with value ``n``, :attr:`input` is split into ``n`` sections along dimension :attr:`dim`.
|
|||
|
|
If :attr:`input` is divisible by ``n`` along dimension :attr:`dim`, each
|
|||
|
|
section will be of equal size, :code:`input.size(dim) / n`. If :attr:`input`
|
|||
|
|
is not divisible by ``n``, the sizes of the first :code:`int(input.size(dim) % n)`
|
|||
|
|
sections will have size :code:`int(input.size(dim) / n) + 1`, and the rest will
|
|||
|
|
have size :code:`int(input.size(dim) / n)`.
|
|||
|
|
|
|||
|
|
If :attr:`indices_or_sections` is a list or tuple of ints, or a one-dimensional long
|
|||
|
|
tensor, then :attr:`input` is split along dimension :attr:`dim` at each of the indices
|
|||
|
|
in the list, tuple or tensor. For instance, :code:`indices_or_sections=[2, 3]` and :code:`dim=0`
|
|||
|
|
would result in the tensors :code:`input[:2]`, :code:`input[2:3]`, and :code:`input[3:]`.
|
|||
|
|
|
|||
|
|
If :attr:`indices_or_sections` is a tensor, it must be a zero-dimensional or one-dimensional
|
|||
|
|
long tensor on the CPU.
|
|||
|
|
|
|||
|
|
dim (int, optional): dimension along which to split the tensor. Default: ``0``
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.arange(8)
|
|||
|
|
>>> torch.tensor_split(x, 3)
|
|||
|
|
(tensor([0, 1, 2]), tensor([3, 4, 5]), tensor([6, 7]))
|
|||
|
|
|
|||
|
|
>>> x = torch.arange(7)
|
|||
|
|
>>> torch.tensor_split(x, 3)
|
|||
|
|
(tensor([0, 1, 2]), tensor([3, 4]), tensor([5, 6]))
|
|||
|
|
>>> torch.tensor_split(x, (1, 6))
|
|||
|
|
(tensor([0]), tensor([1, 2, 3, 4, 5]), tensor([6]))
|
|||
|
|
|
|||
|
|
>>> x = torch.arange(14).reshape(2, 7)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 0, 1, 2, 3, 4, 5, 6],
|
|||
|
|
[ 7, 8, 9, 10, 11, 12, 13]])
|
|||
|
|
>>> torch.tensor_split(x, 3, dim=1)
|
|||
|
|
(tensor([[0, 1, 2],
|
|||
|
|
[7, 8, 9]]),
|
|||
|
|
tensor([[ 3, 4],
|
|||
|
|
[10, 11]]),
|
|||
|
|
tensor([[ 5, 6],
|
|||
|
|
[12, 13]]))
|
|||
|
|
>>> torch.tensor_split(x, (1, 6), dim=1)
|
|||
|
|
(tensor([[0],
|
|||
|
|
[7]]),
|
|||
|
|
tensor([[ 1, 2, 3, 4, 5],
|
|||
|
|
[ 8, 9, 10, 11, 12]]),
|
|||
|
|
tensor([[ 6],
|
|||
|
|
[13]]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def tensor_split(input: Tensor, sections: Union[_int, SymInt], dim: _int = 0) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
tensor_split(input, indices_or_sections, dim=0) -> List of Tensors
|
|||
|
|
|
|||
|
|
Splits a tensor into multiple sub-tensors, all of which are views of :attr:`input`,
|
|||
|
|
along dimension :attr:`dim` according to the indices or number of sections specified
|
|||
|
|
by :attr:`indices_or_sections`. This function is based on NumPy's
|
|||
|
|
:func:`numpy.array_split`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to split
|
|||
|
|
indices_or_sections (Tensor, int or list or tuple of ints):
|
|||
|
|
If :attr:`indices_or_sections` is an integer ``n`` or a zero dimensional long tensor
|
|||
|
|
with value ``n``, :attr:`input` is split into ``n`` sections along dimension :attr:`dim`.
|
|||
|
|
If :attr:`input` is divisible by ``n`` along dimension :attr:`dim`, each
|
|||
|
|
section will be of equal size, :code:`input.size(dim) / n`. If :attr:`input`
|
|||
|
|
is not divisible by ``n``, the sizes of the first :code:`int(input.size(dim) % n)`
|
|||
|
|
sections will have size :code:`int(input.size(dim) / n) + 1`, and the rest will
|
|||
|
|
have size :code:`int(input.size(dim) / n)`.
|
|||
|
|
|
|||
|
|
If :attr:`indices_or_sections` is a list or tuple of ints, or a one-dimensional long
|
|||
|
|
tensor, then :attr:`input` is split along dimension :attr:`dim` at each of the indices
|
|||
|
|
in the list, tuple or tensor. For instance, :code:`indices_or_sections=[2, 3]` and :code:`dim=0`
|
|||
|
|
would result in the tensors :code:`input[:2]`, :code:`input[2:3]`, and :code:`input[3:]`.
|
|||
|
|
|
|||
|
|
If :attr:`indices_or_sections` is a tensor, it must be a zero-dimensional or one-dimensional
|
|||
|
|
long tensor on the CPU.
|
|||
|
|
|
|||
|
|
dim (int, optional): dimension along which to split the tensor. Default: ``0``
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.arange(8)
|
|||
|
|
>>> torch.tensor_split(x, 3)
|
|||
|
|
(tensor([0, 1, 2]), tensor([3, 4, 5]), tensor([6, 7]))
|
|||
|
|
|
|||
|
|
>>> x = torch.arange(7)
|
|||
|
|
>>> torch.tensor_split(x, 3)
|
|||
|
|
(tensor([0, 1, 2]), tensor([3, 4]), tensor([5, 6]))
|
|||
|
|
>>> torch.tensor_split(x, (1, 6))
|
|||
|
|
(tensor([0]), tensor([1, 2, 3, 4, 5]), tensor([6]))
|
|||
|
|
|
|||
|
|
>>> x = torch.arange(14).reshape(2, 7)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 0, 1, 2, 3, 4, 5, 6],
|
|||
|
|
[ 7, 8, 9, 10, 11, 12, 13]])
|
|||
|
|
>>> torch.tensor_split(x, 3, dim=1)
|
|||
|
|
(tensor([[0, 1, 2],
|
|||
|
|
[7, 8, 9]]),
|
|||
|
|
tensor([[ 3, 4],
|
|||
|
|
[10, 11]]),
|
|||
|
|
tensor([[ 5, 6],
|
|||
|
|
[12, 13]]))
|
|||
|
|
>>> torch.tensor_split(x, (1, 6), dim=1)
|
|||
|
|
(tensor([[0],
|
|||
|
|
[7]]),
|
|||
|
|
tensor([[ 1, 2, 3, 4, 5],
|
|||
|
|
[ 8, 9, 10, 11, 12]]),
|
|||
|
|
tensor([[ 6],
|
|||
|
|
[13]]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def tensor_split(input: Tensor, indices: Sequence[Union[_int, SymInt]], dim: _int = 0) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
tensor_split(input, indices_or_sections, dim=0) -> List of Tensors
|
|||
|
|
|
|||
|
|
Splits a tensor into multiple sub-tensors, all of which are views of :attr:`input`,
|
|||
|
|
along dimension :attr:`dim` according to the indices or number of sections specified
|
|||
|
|
by :attr:`indices_or_sections`. This function is based on NumPy's
|
|||
|
|
:func:`numpy.array_split`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor to split
|
|||
|
|
indices_or_sections (Tensor, int or list or tuple of ints):
|
|||
|
|
If :attr:`indices_or_sections` is an integer ``n`` or a zero dimensional long tensor
|
|||
|
|
with value ``n``, :attr:`input` is split into ``n`` sections along dimension :attr:`dim`.
|
|||
|
|
If :attr:`input` is divisible by ``n`` along dimension :attr:`dim`, each
|
|||
|
|
section will be of equal size, :code:`input.size(dim) / n`. If :attr:`input`
|
|||
|
|
is not divisible by ``n``, the sizes of the first :code:`int(input.size(dim) % n)`
|
|||
|
|
sections will have size :code:`int(input.size(dim) / n) + 1`, and the rest will
|
|||
|
|
have size :code:`int(input.size(dim) / n)`.
|
|||
|
|
|
|||
|
|
If :attr:`indices_or_sections` is a list or tuple of ints, or a one-dimensional long
|
|||
|
|
tensor, then :attr:`input` is split along dimension :attr:`dim` at each of the indices
|
|||
|
|
in the list, tuple or tensor. For instance, :code:`indices_or_sections=[2, 3]` and :code:`dim=0`
|
|||
|
|
would result in the tensors :code:`input[:2]`, :code:`input[2:3]`, and :code:`input[3:]`.
|
|||
|
|
|
|||
|
|
If :attr:`indices_or_sections` is a tensor, it must be a zero-dimensional or one-dimensional
|
|||
|
|
long tensor on the CPU.
|
|||
|
|
|
|||
|
|
dim (int, optional): dimension along which to split the tensor. Default: ``0``
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.arange(8)
|
|||
|
|
>>> torch.tensor_split(x, 3)
|
|||
|
|
(tensor([0, 1, 2]), tensor([3, 4, 5]), tensor([6, 7]))
|
|||
|
|
|
|||
|
|
>>> x = torch.arange(7)
|
|||
|
|
>>> torch.tensor_split(x, 3)
|
|||
|
|
(tensor([0, 1, 2]), tensor([3, 4]), tensor([5, 6]))
|
|||
|
|
>>> torch.tensor_split(x, (1, 6))
|
|||
|
|
(tensor([0]), tensor([1, 2, 3, 4, 5]), tensor([6]))
|
|||
|
|
|
|||
|
|
>>> x = torch.arange(14).reshape(2, 7)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 0, 1, 2, 3, 4, 5, 6],
|
|||
|
|
[ 7, 8, 9, 10, 11, 12, 13]])
|
|||
|
|
>>> torch.tensor_split(x, 3, dim=1)
|
|||
|
|
(tensor([[0, 1, 2],
|
|||
|
|
[7, 8, 9]]),
|
|||
|
|
tensor([[ 3, 4],
|
|||
|
|
[10, 11]]),
|
|||
|
|
tensor([[ 5, 6],
|
|||
|
|
[12, 13]]))
|
|||
|
|
>>> torch.tensor_split(x, (1, 6), dim=1)
|
|||
|
|
(tensor([[0],
|
|||
|
|
[7]]),
|
|||
|
|
tensor([[ 1, 2, 3, 4, 5],
|
|||
|
|
[ 8, 9, 10, 11, 12]]),
|
|||
|
|
tensor([[ 6],
|
|||
|
|
[13]]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def threshold(input: Tensor, threshold: Union[Number, _complex], value: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor: ...
|
|||
|
|
def threshold_(input: Tensor, threshold: Union[Number, _complex], value: Union[Number, _complex]) -> Tensor: ...
|
|||
|
|
def tile(input: Tensor, dims: Sequence[Union[_int, SymInt]]) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
tile(input, dims) -> Tensor
|
|||
|
|
|
|||
|
|
Constructs a tensor by repeating the elements of :attr:`input`.
|
|||
|
|
The :attr:`dims` argument specifies the number of repetitions
|
|||
|
|
in each dimension.
|
|||
|
|
|
|||
|
|
If :attr:`dims` specifies fewer dimensions than :attr:`input` has, then
|
|||
|
|
ones are prepended to :attr:`dims` until all dimensions are specified.
|
|||
|
|
For example, if :attr:`input` has shape (8, 6, 4, 2) and :attr:`dims`
|
|||
|
|
is (2, 2), then :attr:`dims` is treated as (1, 1, 2, 2).
|
|||
|
|
|
|||
|
|
Analogously, if :attr:`input` has fewer dimensions than :attr:`dims`
|
|||
|
|
specifies, then :attr:`input` is treated as if it were unsqueezed at
|
|||
|
|
dimension zero until it has as many dimensions as :attr:`dims` specifies.
|
|||
|
|
For example, if :attr:`input` has shape (4, 2) and :attr:`dims`
|
|||
|
|
is (3, 3, 2, 2), then :attr:`input` is treated as if it had the
|
|||
|
|
shape (1, 1, 4, 2).
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
This function is similar to NumPy's tile function.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the tensor whose elements to repeat.
|
|||
|
|
dims (tuple): the number of repetitions per dimension.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.tensor([1, 2, 3])
|
|||
|
|
>>> x.tile((2,))
|
|||
|
|
tensor([1, 2, 3, 1, 2, 3])
|
|||
|
|
>>> y = torch.tensor([[1, 2], [3, 4]])
|
|||
|
|
>>> torch.tile(y, (2, 2))
|
|||
|
|
tensor([[1, 2, 1, 2],
|
|||
|
|
[3, 4, 3, 4],
|
|||
|
|
[1, 2, 1, 2],
|
|||
|
|
[3, 4, 3, 4]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def topk(input: Tensor, k: Union[_int, SymInt], dim: _int = -1, largest: _bool = True, sorted: _bool = True, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.topk:
|
|||
|
|
r"""
|
|||
|
|
topk(input, k, dim=None, largest=True, sorted=True, *, out=None) -> (Tensor, LongTensor)
|
|||
|
|
|
|||
|
|
Returns the :attr:`k` largest elements of the given :attr:`input` tensor along
|
|||
|
|
a given dimension.
|
|||
|
|
|
|||
|
|
If :attr:`dim` is not given, the last dimension of the `input` is chosen.
|
|||
|
|
|
|||
|
|
If :attr:`largest` is ``False`` then the `k` smallest elements are returned.
|
|||
|
|
|
|||
|
|
A namedtuple of `(values, indices)` is returned with the `values` and
|
|||
|
|
`indices` of the largest `k` elements of each row of the `input` tensor in the
|
|||
|
|
given dimension `dim`.
|
|||
|
|
|
|||
|
|
The boolean option :attr:`sorted` if ``True``, will make sure that the returned
|
|||
|
|
`k` elements are themselves sorted
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
k (int): the k in "top-k"
|
|||
|
|
dim (int, optional): the dimension to sort along
|
|||
|
|
largest (bool, optional): controls whether to return largest or
|
|||
|
|
smallest elements
|
|||
|
|
sorted (bool, optional): controls whether to return the elements
|
|||
|
|
in sorted order
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (tuple, optional): the output tuple of (Tensor, LongTensor) that can be
|
|||
|
|
optionally given to be used as output buffers
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.arange(1., 6.)
|
|||
|
|
>>> x
|
|||
|
|
tensor([ 1., 2., 3., 4., 5.])
|
|||
|
|
>>> torch.topk(x, 3)
|
|||
|
|
torch.return_types.topk(values=tensor([5., 4., 3.]), indices=tensor([4, 3, 2]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def trace(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
trace(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the sum of the elements of the diagonal of the input 2-D matrix.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.arange(1., 10.).view(3, 3)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 1., 2., 3.],
|
|||
|
|
[ 4., 5., 6.],
|
|||
|
|
[ 7., 8., 9.]])
|
|||
|
|
>>> torch.trace(x)
|
|||
|
|
tensor(15.)
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def transpose(input: Tensor, dim0: _int, dim1: _int) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
transpose(input, dim0, dim1) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor that is a transposed version of :attr:`input`.
|
|||
|
|
The given dimensions :attr:`dim0` and :attr:`dim1` are swapped.
|
|||
|
|
|
|||
|
|
If :attr:`input` is a strided tensor then the resulting :attr:`out`
|
|||
|
|
tensor shares its underlying storage with the :attr:`input` tensor, so
|
|||
|
|
changing the content of one would change the content of the other.
|
|||
|
|
|
|||
|
|
If :attr:`input` is a :ref:`sparse tensor <sparse-docs>` then the
|
|||
|
|
resulting :attr:`out` tensor *does not* share the underlying storage
|
|||
|
|
with the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
If :attr:`input` is a :ref:`sparse tensor <sparse-docs>` with compressed
|
|||
|
|
layout (SparseCSR, SparseBSR, SparseCSC or SparseBSC) the arguments
|
|||
|
|
:attr:`dim0` and :attr:`dim1` must be both batch dimensions, or must
|
|||
|
|
both be sparse dimensions. The batch dimensions of a sparse tensor are the
|
|||
|
|
dimensions preceding the sparse dimensions.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
Transpositions which interchange the sparse dimensions of a `SparseCSR`
|
|||
|
|
or `SparseCSC` layout tensor will result in the layout changing between
|
|||
|
|
the two options. Transposition of the sparse dimensions of a ` SparseBSR`
|
|||
|
|
or `SparseBSC` layout tensor will likewise generate a result with the
|
|||
|
|
opposite layout.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim0 (int): the first dimension to be transposed
|
|||
|
|
dim1 (int): the second dimension to be transposed
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(2, 3)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 1.0028, -0.9893, 0.5809],
|
|||
|
|
[-0.1669, 0.7299, 0.4942]])
|
|||
|
|
>>> torch.transpose(x, 0, 1)
|
|||
|
|
tensor([[ 1.0028, -0.1669],
|
|||
|
|
[-0.9893, 0.7299],
|
|||
|
|
[ 0.5809, 0.4942]])
|
|||
|
|
|
|||
|
|
See also :func:`torch.t`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def transpose(input: Tensor, dim0: Union[str, ellipsis, None], dim1: Union[str, ellipsis, None]) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
transpose(input, dim0, dim1) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor that is a transposed version of :attr:`input`.
|
|||
|
|
The given dimensions :attr:`dim0` and :attr:`dim1` are swapped.
|
|||
|
|
|
|||
|
|
If :attr:`input` is a strided tensor then the resulting :attr:`out`
|
|||
|
|
tensor shares its underlying storage with the :attr:`input` tensor, so
|
|||
|
|
changing the content of one would change the content of the other.
|
|||
|
|
|
|||
|
|
If :attr:`input` is a :ref:`sparse tensor <sparse-docs>` then the
|
|||
|
|
resulting :attr:`out` tensor *does not* share the underlying storage
|
|||
|
|
with the :attr:`input` tensor.
|
|||
|
|
|
|||
|
|
If :attr:`input` is a :ref:`sparse tensor <sparse-docs>` with compressed
|
|||
|
|
layout (SparseCSR, SparseBSR, SparseCSC or SparseBSC) the arguments
|
|||
|
|
:attr:`dim0` and :attr:`dim1` must be both batch dimensions, or must
|
|||
|
|
both be sparse dimensions. The batch dimensions of a sparse tensor are the
|
|||
|
|
dimensions preceding the sparse dimensions.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
Transpositions which interchange the sparse dimensions of a `SparseCSR`
|
|||
|
|
or `SparseCSC` layout tensor will result in the layout changing between
|
|||
|
|
the two options. Transposition of the sparse dimensions of a ` SparseBSR`
|
|||
|
|
or `SparseBSC` layout tensor will likewise generate a result with the
|
|||
|
|
opposite layout.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim0 (int): the first dimension to be transposed
|
|||
|
|
dim1 (int): the second dimension to be transposed
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(2, 3)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 1.0028, -0.9893, 0.5809],
|
|||
|
|
[-0.1669, 0.7299, 0.4942]])
|
|||
|
|
>>> torch.transpose(x, 0, 1)
|
|||
|
|
tensor([[ 1.0028, -0.1669],
|
|||
|
|
[-0.9893, 0.7299],
|
|||
|
|
[ 0.5809, 0.4942]])
|
|||
|
|
|
|||
|
|
See also :func:`torch.t`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def transpose_copy(input: Tensor, dim0: _int, dim1: _int, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.transpose`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def trapezoid(y: Tensor, x: Tensor, *, dim: _int = -1) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
trapezoid(y, x=None, *, dx=None, dim=-1) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the `trapezoidal rule <https://en.wikipedia.org/wiki/Trapezoidal_rule>`_ along
|
|||
|
|
:attr:`dim`. By default the spacing between elements is assumed to be 1, but
|
|||
|
|
:attr:`dx` can be used to specify a different constant spacing, and :attr:`x` can be
|
|||
|
|
used to specify arbitrary spacing along :attr:`dim`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Assuming :attr:`y` is a one-dimensional tensor with elements :math:`{y_0, y_1, ..., y_n}`,
|
|||
|
|
the default computation is
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\begin{aligned}
|
|||
|
|
\sum_{i = 1}^{n-1} \frac{1}{2} (y_i + y_{i-1})
|
|||
|
|
\end{aligned}
|
|||
|
|
|
|||
|
|
When :attr:`dx` is specified the computation becomes
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\begin{aligned}
|
|||
|
|
\sum_{i = 1}^{n-1} \frac{\Delta x}{2} (y_i + y_{i-1})
|
|||
|
|
\end{aligned}
|
|||
|
|
|
|||
|
|
effectively multiplying the result by :attr:`dx`. When :attr:`x` is specified,
|
|||
|
|
assuming :attr:`x` is also a one-dimensional tensor with
|
|||
|
|
elements :math:`{x_0, x_1, ..., x_n}`, the computation becomes
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\begin{aligned}
|
|||
|
|
\sum_{i = 1}^{n-1} \frac{(x_i - x_{i-1})}{2} (y_i + y_{i-1})
|
|||
|
|
\end{aligned}
|
|||
|
|
|
|||
|
|
When :attr:`x` and :attr:`y` have the same size, the computation is as described above and no broadcasting is needed.
|
|||
|
|
The broadcasting behavior of this function is as follows when their sizes are different. For both :attr:`x`
|
|||
|
|
and :attr:`y`, the function computes the difference between consecutive elements along
|
|||
|
|
dimension :attr:`dim`. This effectively creates two tensors, `x_diff` and `y_diff`, that have
|
|||
|
|
the same shape as the original tensors except their lengths along the dimension :attr:`dim` is reduced by 1.
|
|||
|
|
After that, those two tensors are broadcast together to compute final output as part of the trapezoidal rule.
|
|||
|
|
See the examples below for details.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
The trapezoidal rule is a technique for approximating the definite integral of a function
|
|||
|
|
by averaging its left and right Riemann sums. The approximation becomes more accurate as
|
|||
|
|
the resolution of the partition increases.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
y (Tensor): Values to use when computing the trapezoidal rule.
|
|||
|
|
x (Tensor): If specified, defines spacing between values as specified above.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
dx (float): constant spacing between values. If neither :attr:`x` or :attr:`dx`
|
|||
|
|
are specified then this defaults to 1. Effectively multiplies the result by its value.
|
|||
|
|
dim (int): The dimension along which to compute the trapezoidal rule.
|
|||
|
|
The last (inner-most) dimension by default.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> # Computes the trapezoidal rule in 1D, spacing is implicitly 1
|
|||
|
|
>>> y = torch.tensor([1, 5, 10])
|
|||
|
|
>>> torch.trapezoid(y)
|
|||
|
|
tensor(10.5)
|
|||
|
|
|
|||
|
|
>>> # Computes the same trapezoidal rule directly to verify
|
|||
|
|
>>> (1 + 10 + 10) / 2
|
|||
|
|
10.5
|
|||
|
|
|
|||
|
|
>>> # Computes the trapezoidal rule in 1D with constant spacing of 2
|
|||
|
|
>>> # NOTE: the result is the same as before, but multiplied by 2
|
|||
|
|
>>> torch.trapezoid(y, dx=2)
|
|||
|
|
21.0
|
|||
|
|
|
|||
|
|
>>> # Computes the trapezoidal rule in 1D with arbitrary spacing
|
|||
|
|
>>> x = torch.tensor([1, 3, 6])
|
|||
|
|
>>> torch.trapezoid(y, x)
|
|||
|
|
28.5
|
|||
|
|
|
|||
|
|
>>> # Computes the same trapezoidal rule directly to verify
|
|||
|
|
>>> ((3 - 1) * (1 + 5) + (6 - 3) * (5 + 10)) / 2
|
|||
|
|
28.5
|
|||
|
|
|
|||
|
|
>>> # Computes the trapezoidal rule for each row of a 3x3 matrix
|
|||
|
|
>>> y = torch.arange(9).reshape(3, 3)
|
|||
|
|
tensor([[0, 1, 2],
|
|||
|
|
[3, 4, 5],
|
|||
|
|
[6, 7, 8]])
|
|||
|
|
>>> torch.trapezoid(y)
|
|||
|
|
tensor([ 2., 8., 14.])
|
|||
|
|
|
|||
|
|
>>> # Computes the trapezoidal rule for each column of the matrix
|
|||
|
|
>>> torch.trapezoid(y, dim=0)
|
|||
|
|
tensor([ 6., 8., 10.])
|
|||
|
|
|
|||
|
|
>>> # Computes the trapezoidal rule for each row of a 3x3 ones matrix
|
|||
|
|
>>> # with the same arbitrary spacing
|
|||
|
|
>>> y = torch.ones(3, 3)
|
|||
|
|
>>> x = torch.tensor([1, 3, 6])
|
|||
|
|
>>> torch.trapezoid(y, x)
|
|||
|
|
array([5., 5., 5.])
|
|||
|
|
|
|||
|
|
>>> # Computes the trapezoidal rule for each row of a 3x3 ones matrix
|
|||
|
|
>>> # with different arbitrary spacing per row
|
|||
|
|
>>> y = torch.ones(3, 3)
|
|||
|
|
>>> x = torch.tensor([[1, 2, 3], [1, 3, 5], [1, 4, 7]])
|
|||
|
|
>>> torch.trapezoid(y, x)
|
|||
|
|
array([2., 4., 6.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def trapezoid(y: Tensor, *, dx: Union[Number, _complex] = 1, dim: _int = -1) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
trapezoid(y, x=None, *, dx=None, dim=-1) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the `trapezoidal rule <https://en.wikipedia.org/wiki/Trapezoidal_rule>`_ along
|
|||
|
|
:attr:`dim`. By default the spacing between elements is assumed to be 1, but
|
|||
|
|
:attr:`dx` can be used to specify a different constant spacing, and :attr:`x` can be
|
|||
|
|
used to specify arbitrary spacing along :attr:`dim`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Assuming :attr:`y` is a one-dimensional tensor with elements :math:`{y_0, y_1, ..., y_n}`,
|
|||
|
|
the default computation is
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\begin{aligned}
|
|||
|
|
\sum_{i = 1}^{n-1} \frac{1}{2} (y_i + y_{i-1})
|
|||
|
|
\end{aligned}
|
|||
|
|
|
|||
|
|
When :attr:`dx` is specified the computation becomes
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\begin{aligned}
|
|||
|
|
\sum_{i = 1}^{n-1} \frac{\Delta x}{2} (y_i + y_{i-1})
|
|||
|
|
\end{aligned}
|
|||
|
|
|
|||
|
|
effectively multiplying the result by :attr:`dx`. When :attr:`x` is specified,
|
|||
|
|
assuming :attr:`x` is also a one-dimensional tensor with
|
|||
|
|
elements :math:`{x_0, x_1, ..., x_n}`, the computation becomes
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\begin{aligned}
|
|||
|
|
\sum_{i = 1}^{n-1} \frac{(x_i - x_{i-1})}{2} (y_i + y_{i-1})
|
|||
|
|
\end{aligned}
|
|||
|
|
|
|||
|
|
When :attr:`x` and :attr:`y` have the same size, the computation is as described above and no broadcasting is needed.
|
|||
|
|
The broadcasting behavior of this function is as follows when their sizes are different. For both :attr:`x`
|
|||
|
|
and :attr:`y`, the function computes the difference between consecutive elements along
|
|||
|
|
dimension :attr:`dim`. This effectively creates two tensors, `x_diff` and `y_diff`, that have
|
|||
|
|
the same shape as the original tensors except their lengths along the dimension :attr:`dim` is reduced by 1.
|
|||
|
|
After that, those two tensors are broadcast together to compute final output as part of the trapezoidal rule.
|
|||
|
|
See the examples below for details.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
The trapezoidal rule is a technique for approximating the definite integral of a function
|
|||
|
|
by averaging its left and right Riemann sums. The approximation becomes more accurate as
|
|||
|
|
the resolution of the partition increases.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
y (Tensor): Values to use when computing the trapezoidal rule.
|
|||
|
|
x (Tensor): If specified, defines spacing between values as specified above.
|
|||
|
|
|
|||
|
|
Keyword arguments:
|
|||
|
|
dx (float): constant spacing between values. If neither :attr:`x` or :attr:`dx`
|
|||
|
|
are specified then this defaults to 1. Effectively multiplies the result by its value.
|
|||
|
|
dim (int): The dimension along which to compute the trapezoidal rule.
|
|||
|
|
The last (inner-most) dimension by default.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> # Computes the trapezoidal rule in 1D, spacing is implicitly 1
|
|||
|
|
>>> y = torch.tensor([1, 5, 10])
|
|||
|
|
>>> torch.trapezoid(y)
|
|||
|
|
tensor(10.5)
|
|||
|
|
|
|||
|
|
>>> # Computes the same trapezoidal rule directly to verify
|
|||
|
|
>>> (1 + 10 + 10) / 2
|
|||
|
|
10.5
|
|||
|
|
|
|||
|
|
>>> # Computes the trapezoidal rule in 1D with constant spacing of 2
|
|||
|
|
>>> # NOTE: the result is the same as before, but multiplied by 2
|
|||
|
|
>>> torch.trapezoid(y, dx=2)
|
|||
|
|
21.0
|
|||
|
|
|
|||
|
|
>>> # Computes the trapezoidal rule in 1D with arbitrary spacing
|
|||
|
|
>>> x = torch.tensor([1, 3, 6])
|
|||
|
|
>>> torch.trapezoid(y, x)
|
|||
|
|
28.5
|
|||
|
|
|
|||
|
|
>>> # Computes the same trapezoidal rule directly to verify
|
|||
|
|
>>> ((3 - 1) * (1 + 5) + (6 - 3) * (5 + 10)) / 2
|
|||
|
|
28.5
|
|||
|
|
|
|||
|
|
>>> # Computes the trapezoidal rule for each row of a 3x3 matrix
|
|||
|
|
>>> y = torch.arange(9).reshape(3, 3)
|
|||
|
|
tensor([[0, 1, 2],
|
|||
|
|
[3, 4, 5],
|
|||
|
|
[6, 7, 8]])
|
|||
|
|
>>> torch.trapezoid(y)
|
|||
|
|
tensor([ 2., 8., 14.])
|
|||
|
|
|
|||
|
|
>>> # Computes the trapezoidal rule for each column of the matrix
|
|||
|
|
>>> torch.trapezoid(y, dim=0)
|
|||
|
|
tensor([ 6., 8., 10.])
|
|||
|
|
|
|||
|
|
>>> # Computes the trapezoidal rule for each row of a 3x3 ones matrix
|
|||
|
|
>>> # with the same arbitrary spacing
|
|||
|
|
>>> y = torch.ones(3, 3)
|
|||
|
|
>>> x = torch.tensor([1, 3, 6])
|
|||
|
|
>>> torch.trapezoid(y, x)
|
|||
|
|
array([5., 5., 5.])
|
|||
|
|
|
|||
|
|
>>> # Computes the trapezoidal rule for each row of a 3x3 ones matrix
|
|||
|
|
>>> # with different arbitrary spacing per row
|
|||
|
|
>>> y = torch.ones(3, 3)
|
|||
|
|
>>> x = torch.tensor([[1, 2, 3], [1, 3, 5], [1, 4, 7]])
|
|||
|
|
>>> torch.trapezoid(y, x)
|
|||
|
|
array([2., 4., 6.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def trapz(y: Tensor, *, dx: _float = 1, dim: _int = -1) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
trapz(y, x, *, dim=-1) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.trapezoid`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def trapz(y: Tensor, x: Tensor, *, dim: _int = -1) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
trapz(y, x, *, dim=-1) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.trapezoid`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def triangular_solve(input: Tensor, A: Tensor, upper: _bool = True, transpose: _bool = False, unitriangular: _bool = False, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None] = None) -> torch.return_types.triangular_solve:
|
|||
|
|
r"""
|
|||
|
|
triangular_solve(b, A, upper=True, transpose=False, unitriangular=False, *, out=None) -> (Tensor, Tensor)
|
|||
|
|
|
|||
|
|
Solves a system of equations with a square upper or lower triangular invertible matrix :math:`A`
|
|||
|
|
and multiple right-hand sides :math:`b`.
|
|||
|
|
|
|||
|
|
In symbols, it solves :math:`AX = b` and assumes :math:`A` is square upper-triangular
|
|||
|
|
(or lower-triangular if :attr:`upper`\ `= False`) and does not have zeros on the diagonal.
|
|||
|
|
|
|||
|
|
`torch.triangular_solve(b, A)` can take in 2D inputs `b, A` or inputs that are
|
|||
|
|
batches of 2D matrices. If the inputs are batches, then returns
|
|||
|
|
batched outputs `X`
|
|||
|
|
|
|||
|
|
If the diagonal of :attr:`A` contains zeros or elements that are very close to zero and
|
|||
|
|
:attr:`unitriangular`\ `= False` (default) or if the input matrix is badly conditioned,
|
|||
|
|
the result may contain `NaN` s.
|
|||
|
|
|
|||
|
|
Supports input of float, double, cfloat and cdouble data types.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
|
|||
|
|
:func:`torch.triangular_solve` is deprecated in favor of :func:`torch.linalg.solve_triangular`
|
|||
|
|
and will be removed in a future PyTorch release.
|
|||
|
|
:func:`torch.linalg.solve_triangular` has its arguments reversed and does not return a
|
|||
|
|
copy of one of the inputs.
|
|||
|
|
|
|||
|
|
``X = torch.triangular_solve(B, A).solution`` should be replaced with
|
|||
|
|
|
|||
|
|
.. code:: python
|
|||
|
|
|
|||
|
|
X = torch.linalg.solve_triangular(A, B)
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
b (Tensor): multiple right-hand sides of size :math:`(*, m, k)` where
|
|||
|
|
:math:`*` is zero of more batch dimensions
|
|||
|
|
A (Tensor): the input triangular coefficient matrix of size :math:`(*, m, m)`
|
|||
|
|
where :math:`*` is zero or more batch dimensions
|
|||
|
|
upper (bool, optional): whether :math:`A` is upper or lower triangular. Default: ``True``.
|
|||
|
|
transpose (bool, optional): solves `op(A)X = b` where `op(A) = A^T` if this flag is ``True``,
|
|||
|
|
and `op(A) = A` if it is ``False``. Default: ``False``.
|
|||
|
|
unitriangular (bool, optional): whether :math:`A` is unit triangular.
|
|||
|
|
If True, the diagonal elements of :math:`A` are assumed to be
|
|||
|
|
1 and not referenced from :math:`A`. Default: ``False``.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out ((Tensor, Tensor), optional): tuple of two tensors to write
|
|||
|
|
the output to. Ignored if `None`. Default: `None`.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A namedtuple `(solution, cloned_coefficient)` where `cloned_coefficient`
|
|||
|
|
is a clone of :math:`A` and `solution` is the solution :math:`X` to :math:`AX = b`
|
|||
|
|
(or whatever variant of the system of equations, depending on the keyword arguments.)
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
|
|||
|
|
>>> A = torch.randn(2, 2).triu()
|
|||
|
|
>>> A
|
|||
|
|
tensor([[ 1.1527, -1.0753],
|
|||
|
|
[ 0.0000, 0.7986]])
|
|||
|
|
>>> b = torch.randn(2, 3)
|
|||
|
|
>>> b
|
|||
|
|
tensor([[-0.0210, 2.3513, -1.5492],
|
|||
|
|
[ 1.5429, 0.7403, -1.0243]])
|
|||
|
|
>>> torch.triangular_solve(b, A)
|
|||
|
|
torch.return_types.triangular_solve(
|
|||
|
|
solution=tensor([[ 1.7841, 2.9046, -2.5405],
|
|||
|
|
[ 1.9320, 0.9270, -1.2826]]),
|
|||
|
|
cloned_coefficient=tensor([[ 1.1527, -1.0753],
|
|||
|
|
[ 0.0000, 0.7986]]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def tril(input: Tensor, diagonal: _int = 0, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
tril(input, diagonal=0, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the lower triangular part of the matrix (2-D tensor) or batch of matrices
|
|||
|
|
:attr:`input`, the other elements of the result tensor :attr:`out` are set to 0.
|
|||
|
|
|
|||
|
|
The lower triangular part of the matrix is defined as the elements on and
|
|||
|
|
below the diagonal.
|
|||
|
|
|
|||
|
|
The argument :attr:`diagonal` controls which diagonal to consider. If
|
|||
|
|
:attr:`diagonal` = 0, all elements on and below the main diagonal are
|
|||
|
|
retained. A positive value includes just as many diagonals above the main
|
|||
|
|
diagonal, and similarly a negative value excludes just as many diagonals below
|
|||
|
|
the main diagonal. The main diagonal are the set of indices
|
|||
|
|
:math:`\lbrace (i, i) \rbrace` for :math:`i \in [0, \min\{d_{1}, d_{2}\} - 1]` where
|
|||
|
|
:math:`d_{1}, d_{2}` are the dimensions of the matrix.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
diagonal (int, optional): the diagonal to consider
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(3, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[-1.0813, -0.8619, 0.7105],
|
|||
|
|
[ 0.0935, 0.1380, 2.2112],
|
|||
|
|
[-0.3409, -0.9828, 0.0289]])
|
|||
|
|
>>> torch.tril(a)
|
|||
|
|
tensor([[-1.0813, 0.0000, 0.0000],
|
|||
|
|
[ 0.0935, 0.1380, 0.0000],
|
|||
|
|
[-0.3409, -0.9828, 0.0289]])
|
|||
|
|
|
|||
|
|
>>> b = torch.randn(4, 6)
|
|||
|
|
>>> b
|
|||
|
|
tensor([[ 1.2219, 0.5653, -0.2521, -0.2345, 1.2544, 0.3461],
|
|||
|
|
[ 0.4785, -0.4477, 0.6049, 0.6368, 0.8775, 0.7145],
|
|||
|
|
[ 1.1502, 3.2716, -1.1243, -0.5413, 0.3615, 0.6864],
|
|||
|
|
[-0.0614, -0.7344, -1.3164, -0.7648, -1.4024, 0.0978]])
|
|||
|
|
>>> torch.tril(b, diagonal=1)
|
|||
|
|
tensor([[ 1.2219, 0.5653, 0.0000, 0.0000, 0.0000, 0.0000],
|
|||
|
|
[ 0.4785, -0.4477, 0.6049, 0.0000, 0.0000, 0.0000],
|
|||
|
|
[ 1.1502, 3.2716, -1.1243, -0.5413, 0.0000, 0.0000],
|
|||
|
|
[-0.0614, -0.7344, -1.3164, -0.7648, -1.4024, 0.0000]])
|
|||
|
|
>>> torch.tril(b, diagonal=-1)
|
|||
|
|
tensor([[ 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
|
|||
|
|
[ 0.4785, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
|
|||
|
|
[ 1.1502, 3.2716, 0.0000, 0.0000, 0.0000, 0.0000],
|
|||
|
|
[-0.0614, -0.7344, -1.3164, 0.0000, 0.0000, 0.0000]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def tril_indices(row: _int, col: _int, offset: _int = 0, *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
tril_indices(row, col, offset=0, *, dtype=torch.long, device='cpu', layout=torch.strided) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the indices of the lower triangular part of a :attr:`row`-by-
|
|||
|
|
:attr:`col` matrix in a 2-by-N Tensor, where the first row contains row
|
|||
|
|
coordinates of all indices and the second row contains column coordinates.
|
|||
|
|
Indices are ordered based on rows and then columns.
|
|||
|
|
|
|||
|
|
The lower triangular part of the matrix is defined as the elements on and
|
|||
|
|
below the diagonal.
|
|||
|
|
|
|||
|
|
The argument :attr:`offset` controls which diagonal to consider. If
|
|||
|
|
:attr:`offset` = 0, all elements on and below the main diagonal are
|
|||
|
|
retained. A positive value includes just as many diagonals above the main
|
|||
|
|
diagonal, and similarly a negative value excludes just as many diagonals below
|
|||
|
|
the main diagonal. The main diagonal are the set of indices
|
|||
|
|
:math:`\lbrace (i, i) \rbrace` for :math:`i \in [0, \min\{d_{1}, d_{2}\} - 1]`
|
|||
|
|
where :math:`d_{1}, d_{2}` are the dimensions of the matrix.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
When running on CUDA, ``row * col`` must be less than :math:`2^{59}` to
|
|||
|
|
prevent overflow during calculation.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
row (``int``): number of rows in the 2-D matrix.
|
|||
|
|
col (``int``): number of columns in the 2-D matrix.
|
|||
|
|
offset (``int``): diagonal offset from the main diagonal.
|
|||
|
|
Default: if not provided, 0.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, ``torch.long``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
layout (:class:`torch.layout`, optional): currently only support ``torch.strided``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tril_indices(3, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[0, 1, 1, 2, 2, 2],
|
|||
|
|
[0, 0, 1, 0, 1, 2]])
|
|||
|
|
|
|||
|
|
>>> a = torch.tril_indices(4, 3, -1)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[1, 2, 2, 3, 3, 3],
|
|||
|
|
[0, 0, 1, 0, 1, 2]])
|
|||
|
|
|
|||
|
|
>>> a = torch.tril_indices(4, 3, 1)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3],
|
|||
|
|
[0, 1, 0, 1, 2, 0, 1, 2, 0, 1, 2]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def triplet_margin_loss(anchor: Tensor, positive: Tensor, negative: Tensor, margin: _float = 1.0, p: _float = 2, eps: _float = 1e-06, swap: _bool = False, reduction: _int = 1) -> Tensor: ...
|
|||
|
|
def triu(input: Tensor, diagonal: _int = 0, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
triu(input, diagonal=0, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the upper triangular part of a matrix (2-D tensor) or batch of matrices
|
|||
|
|
:attr:`input`, the other elements of the result tensor :attr:`out` are set to 0.
|
|||
|
|
|
|||
|
|
The upper triangular part of the matrix is defined as the elements on and
|
|||
|
|
above the diagonal.
|
|||
|
|
|
|||
|
|
The argument :attr:`diagonal` controls which diagonal to consider. If
|
|||
|
|
:attr:`diagonal` = 0, all elements on and above the main diagonal are
|
|||
|
|
retained. A positive value excludes just as many diagonals above the main
|
|||
|
|
diagonal, and similarly a negative value includes just as many diagonals below
|
|||
|
|
the main diagonal. The main diagonal are the set of indices
|
|||
|
|
:math:`\lbrace (i, i) \rbrace` for :math:`i \in [0, \min\{d_{1}, d_{2}\} - 1]` where
|
|||
|
|
:math:`d_{1}, d_{2}` are the dimensions of the matrix.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
diagonal (int, optional): the diagonal to consider
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(3, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[ 0.2309, 0.5207, 2.0049],
|
|||
|
|
[ 0.2072, -1.0680, 0.6602],
|
|||
|
|
[ 0.3480, -0.5211, -0.4573]])
|
|||
|
|
>>> torch.triu(a)
|
|||
|
|
tensor([[ 0.2309, 0.5207, 2.0049],
|
|||
|
|
[ 0.0000, -1.0680, 0.6602],
|
|||
|
|
[ 0.0000, 0.0000, -0.4573]])
|
|||
|
|
>>> torch.triu(a, diagonal=1)
|
|||
|
|
tensor([[ 0.0000, 0.5207, 2.0049],
|
|||
|
|
[ 0.0000, 0.0000, 0.6602],
|
|||
|
|
[ 0.0000, 0.0000, 0.0000]])
|
|||
|
|
>>> torch.triu(a, diagonal=-1)
|
|||
|
|
tensor([[ 0.2309, 0.5207, 2.0049],
|
|||
|
|
[ 0.2072, -1.0680, 0.6602],
|
|||
|
|
[ 0.0000, -0.5211, -0.4573]])
|
|||
|
|
|
|||
|
|
>>> b = torch.randn(4, 6)
|
|||
|
|
>>> b
|
|||
|
|
tensor([[ 0.5876, -0.0794, -1.8373, 0.6654, 0.2604, 1.5235],
|
|||
|
|
[-0.2447, 0.9556, -1.2919, 1.3378, -0.1768, -1.0857],
|
|||
|
|
[ 0.4333, 0.3146, 0.6576, -1.0432, 0.9348, -0.4410],
|
|||
|
|
[-0.9888, 1.0679, -1.3337, -1.6556, 0.4798, 0.2830]])
|
|||
|
|
>>> torch.triu(b, diagonal=1)
|
|||
|
|
tensor([[ 0.0000, -0.0794, -1.8373, 0.6654, 0.2604, 1.5235],
|
|||
|
|
[ 0.0000, 0.0000, -1.2919, 1.3378, -0.1768, -1.0857],
|
|||
|
|
[ 0.0000, 0.0000, 0.0000, -1.0432, 0.9348, -0.4410],
|
|||
|
|
[ 0.0000, 0.0000, 0.0000, 0.0000, 0.4798, 0.2830]])
|
|||
|
|
>>> torch.triu(b, diagonal=-1)
|
|||
|
|
tensor([[ 0.5876, -0.0794, -1.8373, 0.6654, 0.2604, 1.5235],
|
|||
|
|
[-0.2447, 0.9556, -1.2919, 1.3378, -0.1768, -1.0857],
|
|||
|
|
[ 0.0000, 0.3146, 0.6576, -1.0432, 0.9348, -0.4410],
|
|||
|
|
[ 0.0000, 0.0000, -1.3337, -1.6556, 0.4798, 0.2830]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def triu_indices(row: _int, col: _int, offset: _int = 0, *, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
triu_indices(row, col, offset=0, *, dtype=torch.long, device='cpu', layout=torch.strided) -> Tensor
|
|||
|
|
|
|||
|
|
Returns the indices of the upper triangular part of a :attr:`row` by
|
|||
|
|
:attr:`col` matrix in a 2-by-N Tensor, where the first row contains row
|
|||
|
|
coordinates of all indices and the second row contains column coordinates.
|
|||
|
|
Indices are ordered based on rows and then columns.
|
|||
|
|
|
|||
|
|
The upper triangular part of the matrix is defined as the elements on and
|
|||
|
|
above the diagonal.
|
|||
|
|
|
|||
|
|
The argument :attr:`offset` controls which diagonal to consider. If
|
|||
|
|
:attr:`offset` = 0, all elements on and above the main diagonal are
|
|||
|
|
retained. A positive value excludes just as many diagonals above the main
|
|||
|
|
diagonal, and similarly a negative value includes just as many diagonals below
|
|||
|
|
the main diagonal. The main diagonal are the set of indices
|
|||
|
|
:math:`\lbrace (i, i) \rbrace` for :math:`i \in [0, \min\{d_{1}, d_{2}\} - 1]`
|
|||
|
|
where :math:`d_{1}, d_{2}` are the dimensions of the matrix.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
When running on CUDA, ``row * col`` must be less than :math:`2^{59}` to
|
|||
|
|
prevent overflow during calculation.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
row (``int``): number of rows in the 2-D matrix.
|
|||
|
|
col (``int``): number of columns in the 2-D matrix.
|
|||
|
|
offset (``int``): diagonal offset from the main diagonal.
|
|||
|
|
Default: if not provided, 0.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, ``torch.long``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
layout (:class:`torch.layout`, optional): currently only support ``torch.strided``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.triu_indices(3, 3)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[0, 0, 0, 1, 1, 2],
|
|||
|
|
[0, 1, 2, 1, 2, 2]])
|
|||
|
|
|
|||
|
|
>>> a = torch.triu_indices(4, 3, -1)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[0, 0, 0, 1, 1, 1, 2, 2, 3],
|
|||
|
|
[0, 1, 2, 0, 1, 2, 1, 2, 2]])
|
|||
|
|
|
|||
|
|
>>> a = torch.triu_indices(4, 3, 1)
|
|||
|
|
>>> a
|
|||
|
|
tensor([[0, 0, 1],
|
|||
|
|
[1, 2, 2]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def true_divide(input: Union[Tensor, Number], other: Union[Tensor, Number], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
true_divide(dividend, divisor, *, out) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.div` with ``rounding_mode=None``.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def trunc(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
trunc(input, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with the truncated integer values of
|
|||
|
|
the elements of :attr:`input`.
|
|||
|
|
|
|||
|
|
For integer inputs, follows the array-api convention of returning a
|
|||
|
|
copy of the input tensor.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.randn(4)
|
|||
|
|
>>> a
|
|||
|
|
tensor([ 3.4742, 0.5466, -0.8008, -0.9079])
|
|||
|
|
>>> torch.trunc(a)
|
|||
|
|
tensor([ 3., 0., -0., -0.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def trunc_(input: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def unbind(input: Tensor, dim: _int = 0) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
unbind(input, dim=0) -> seq
|
|||
|
|
|
|||
|
|
Removes a tensor dimension.
|
|||
|
|
|
|||
|
|
Returns a tuple of all slices along a given dimension, already without it.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
input (Tensor): the tensor to unbind
|
|||
|
|
dim (int): dimension to remove
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.unbind(torch.tensor([[1, 2, 3],
|
|||
|
|
>>> [4, 5, 6],
|
|||
|
|
>>> [7, 8, 9]]))
|
|||
|
|
(tensor([1, 2, 3]), tensor([4, 5, 6]), tensor([7, 8, 9]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def unbind(input: Tensor, dim: Union[str, ellipsis, None]) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
unbind(input, dim=0) -> seq
|
|||
|
|
|
|||
|
|
Removes a tensor dimension.
|
|||
|
|
|
|||
|
|
Returns a tuple of all slices along a given dimension, already without it.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
input (Tensor): the tensor to unbind
|
|||
|
|
dim (int): dimension to remove
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.unbind(torch.tensor([[1, 2, 3],
|
|||
|
|
>>> [4, 5, 6],
|
|||
|
|
>>> [7, 8, 9]]))
|
|||
|
|
(tensor([1, 2, 3]), tensor([4, 5, 6]), tensor([7, 8, 9]))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def unbind_copy(input: Tensor, dim: _int = 0, *, out: Union[Tuple[Tensor, ...], List[Tensor], None] = None) -> None:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.unbind`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def unflatten(input: Tensor, dim: Union[str, ellipsis, None], sizes: Sequence[Union[_int, SymInt]], names: Sequence[Union[str, ellipsis, None]]) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
unflatten(input, dim, sizes) -> Tensor
|
|||
|
|
|
|||
|
|
Expands a dimension of the input tensor over multiple dimensions.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.flatten` the inverse of this function. It coalesces several dimensions into one.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): Dimension to be unflattened, specified as an index into
|
|||
|
|
``input.shape``.
|
|||
|
|
sizes (Tuple[int]): New shape of the unflattened dimension.
|
|||
|
|
One of its elements can be `-1` in which case the corresponding output
|
|||
|
|
dimension is inferred. Otherwise, the product of ``sizes`` *must*
|
|||
|
|
equal ``input.shape[dim]``.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A View of input with the specified dimension unflattened.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
>>> torch.unflatten(torch.randn(3, 4, 1), 1, (2, 2)).shape
|
|||
|
|
torch.Size([3, 2, 2, 1])
|
|||
|
|
>>> torch.unflatten(torch.randn(3, 4, 1), 1, (-1, 2)).shape
|
|||
|
|
torch.Size([3, 2, 2, 1])
|
|||
|
|
>>> torch.unflatten(torch.randn(5, 12, 3), -2, (2, 2, 3, 1, 1)).shape
|
|||
|
|
torch.Size([5, 2, 2, 3, 1, 1, 3])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def unflatten(input: Tensor, dim: _int, sizes: Sequence[Union[_int, SymInt]]) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
unflatten(input, dim, sizes) -> Tensor
|
|||
|
|
|
|||
|
|
Expands a dimension of the input tensor over multiple dimensions.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.flatten` the inverse of this function. It coalesces several dimensions into one.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): Dimension to be unflattened, specified as an index into
|
|||
|
|
``input.shape``.
|
|||
|
|
sizes (Tuple[int]): New shape of the unflattened dimension.
|
|||
|
|
One of its elements can be `-1` in which case the corresponding output
|
|||
|
|
dimension is inferred. Otherwise, the product of ``sizes`` *must*
|
|||
|
|
equal ``input.shape[dim]``.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A View of input with the specified dimension unflattened.
|
|||
|
|
|
|||
|
|
Examples::
|
|||
|
|
>>> torch.unflatten(torch.randn(3, 4, 1), 1, (2, 2)).shape
|
|||
|
|
torch.Size([3, 2, 2, 1])
|
|||
|
|
>>> torch.unflatten(torch.randn(3, 4, 1), 1, (-1, 2)).shape
|
|||
|
|
torch.Size([3, 2, 2, 1])
|
|||
|
|
>>> torch.unflatten(torch.randn(5, 12, 3), -2, (2, 2, 3, 1, 1)).shape
|
|||
|
|
torch.Size([5, 2, 2, 3, 1, 1, 3])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def unfold_copy(input: Tensor, dimension: _int, size: _int, step: _int, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.unfold`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def unique_dim(input: Tensor, dim: _int, sorted: _bool = True, return_inverse: _bool = False, return_counts: _bool = False) -> Tuple[Tensor, Tensor, Tensor]: ...
|
|||
|
|
def unsafe_chunk(input: Tensor, chunks: _int, dim: _int = 0) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
unsafe_chunk(input, chunks, dim=0) -> List of Tensors
|
|||
|
|
|
|||
|
|
Works like :func:`torch.chunk` but without enforcing the autograd restrictions
|
|||
|
|
on inplace modification of the outputs.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
This function is safe to use as long as only the input, or only the outputs
|
|||
|
|
are modified inplace after calling this function. It is user's
|
|||
|
|
responsibility to ensure that is the case. If both the input and one or more
|
|||
|
|
of the outputs are modified inplace, gradients computed by autograd will be
|
|||
|
|
silently incorrect.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def unsafe_split(input: Tensor, split_size: Union[_int, SymInt], dim: _int = 0) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
unsafe_split(tensor, split_size_or_sections, dim=0) -> List of Tensors
|
|||
|
|
|
|||
|
|
Works like :func:`torch.split` but without enforcing the autograd restrictions
|
|||
|
|
on inplace modification of the outputs.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
This function is safe to use as long as only the input, or only the outputs
|
|||
|
|
are modified inplace after calling this function. It is user's
|
|||
|
|
responsibility to ensure that is the case. If both the input and one or more
|
|||
|
|
of the outputs are modified inplace, gradients computed by autograd will be
|
|||
|
|
silently incorrect.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def unsafe_split_with_sizes(input: Tensor, split_sizes: Sequence[Union[_int, SymInt]], dim: _int = 0) -> Tuple[Tensor, ...]: ...
|
|||
|
|
def unsqueeze(input: Tensor, dim: _int) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
unsqueeze(input, dim) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a new tensor with a dimension of size one inserted at the
|
|||
|
|
specified position.
|
|||
|
|
|
|||
|
|
The returned tensor shares the same underlying data with this tensor.
|
|||
|
|
|
|||
|
|
A :attr:`dim` value within the range ``[-input.dim() - 1, input.dim() + 1)``
|
|||
|
|
can be used. Negative :attr:`dim` will correspond to :meth:`unsqueeze`
|
|||
|
|
applied at :attr:`dim` = ``dim + input.dim() + 1``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
dim (int): the index at which to insert the singleton dimension
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.tensor([1, 2, 3, 4])
|
|||
|
|
>>> torch.unsqueeze(x, 0)
|
|||
|
|
tensor([[ 1, 2, 3, 4]])
|
|||
|
|
>>> torch.unsqueeze(x, 1)
|
|||
|
|
tensor([[ 1],
|
|||
|
|
[ 2],
|
|||
|
|
[ 3],
|
|||
|
|
[ 4]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def unsqueeze_copy(input: Tensor, dim: _int, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.unsqueeze`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def values_copy(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.values`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def vander(x: Tensor, N: Optional[_int] = None, increasing: _bool = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
vander(x, N=None, increasing=False) -> Tensor
|
|||
|
|
|
|||
|
|
Generates a Vandermonde matrix.
|
|||
|
|
|
|||
|
|
The columns of the output matrix are elementwise powers of the input vector :math:`x^{(N-1)}, x^{(N-2)}, ..., x^0`.
|
|||
|
|
If increasing is True, the order of the columns is reversed :math:`x^0, x^1, ..., x^{(N-1)}`. Such a
|
|||
|
|
matrix with a geometric progression in each row is named for Alexandre-Theophile Vandermonde.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
x (Tensor): 1-D input tensor.
|
|||
|
|
N (int, optional): Number of columns in the output. If N is not specified,
|
|||
|
|
a square array is returned :math:`(N = len(x))`.
|
|||
|
|
increasing (bool, optional): Order of the powers of the columns. If True,
|
|||
|
|
the powers increase from left to right, if False (the default) they are reversed.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: Vandermonde matrix. If increasing is False, the first column is :math:`x^{(N-1)}`,
|
|||
|
|
the second :math:`x^{(N-2)}` and so forth. If increasing is True, the columns
|
|||
|
|
are :math:`x^0, x^1, ..., x^{(N-1)}`.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.tensor([1, 2, 3, 5])
|
|||
|
|
>>> torch.vander(x)
|
|||
|
|
tensor([[ 1, 1, 1, 1],
|
|||
|
|
[ 8, 4, 2, 1],
|
|||
|
|
[ 27, 9, 3, 1],
|
|||
|
|
[125, 25, 5, 1]])
|
|||
|
|
>>> torch.vander(x, N=3)
|
|||
|
|
tensor([[ 1, 1, 1],
|
|||
|
|
[ 4, 2, 1],
|
|||
|
|
[ 9, 3, 1],
|
|||
|
|
[25, 5, 1]])
|
|||
|
|
>>> torch.vander(x, N=3, increasing=True)
|
|||
|
|
tensor([[ 1, 1, 1],
|
|||
|
|
[ 1, 2, 4],
|
|||
|
|
[ 1, 3, 9],
|
|||
|
|
[ 1, 5, 25]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def var(input: Tensor, dim: Optional[Union[_int, _size]], unbiased: _bool = True, keepdim: _bool = False, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
var(input, dim=None, *, correction=1, keepdim=False, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Calculates the variance over the dimensions specified by :attr:`dim`. :attr:`dim`
|
|||
|
|
can be a single dimension, list of dimensions, or ``None`` to reduce over all
|
|||
|
|
dimensions.
|
|||
|
|
|
|||
|
|
The variance (:math:`\sigma^2`) is calculated as
|
|||
|
|
|
|||
|
|
.. math:: \sigma^2 = \frac{1}{\max(0,~N - \delta N)}\sum_{i=0}^{N-1}(x_i-\bar{x})^2
|
|||
|
|
|
|||
|
|
where :math:`x` is the sample set of elements, :math:`\bar{x}` is the
|
|||
|
|
sample mean, :math:`N` is the number of samples and :math:`\delta N` is
|
|||
|
|
the :attr:`correction`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
dim (int or tuple of ints, optional): the dimension or dimensions to reduce.
|
|||
|
|
If ``None``, all dimensions are reduced.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
correction (int): difference between the sample size and sample degrees of freedom.
|
|||
|
|
Defaults to `Bessel's correction`_, ``correction=1``.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
Previously this argument was called ``unbiased`` and was a boolean
|
|||
|
|
with ``True`` corresponding to ``correction=1`` and ``False`` being
|
|||
|
|
``correction=0``.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor(
|
|||
|
|
... [[ 0.2035, 1.2959, 1.8101, -0.4644],
|
|||
|
|
... [ 1.5027, -0.3270, 0.5905, 0.6538],
|
|||
|
|
... [-1.5745, 1.3330, -0.5596, -0.6548],
|
|||
|
|
... [ 0.1264, -0.5080, 1.6420, 0.1992]])
|
|||
|
|
>>> torch.var(a, dim=1, keepdim=True)
|
|||
|
|
tensor([[1.0631],
|
|||
|
|
[0.5590],
|
|||
|
|
[1.4893],
|
|||
|
|
[0.8258]])
|
|||
|
|
|
|||
|
|
.. _Bessel's correction: https://en.wikipedia.org/wiki/Bessel%27s_correction
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def var(input: Tensor, dim: Optional[Union[_int, _size]] = None, *, correction: Optional[Union[Number, _complex]] = None, keepdim: _bool = False, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
var(input, dim=None, *, correction=1, keepdim=False, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Calculates the variance over the dimensions specified by :attr:`dim`. :attr:`dim`
|
|||
|
|
can be a single dimension, list of dimensions, or ``None`` to reduce over all
|
|||
|
|
dimensions.
|
|||
|
|
|
|||
|
|
The variance (:math:`\sigma^2`) is calculated as
|
|||
|
|
|
|||
|
|
.. math:: \sigma^2 = \frac{1}{\max(0,~N - \delta N)}\sum_{i=0}^{N-1}(x_i-\bar{x})^2
|
|||
|
|
|
|||
|
|
where :math:`x` is the sample set of elements, :math:`\bar{x}` is the
|
|||
|
|
sample mean, :math:`N` is the number of samples and :math:`\delta N` is
|
|||
|
|
the :attr:`correction`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
dim (int or tuple of ints, optional): the dimension or dimensions to reduce.
|
|||
|
|
If ``None``, all dimensions are reduced.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
correction (int): difference between the sample size and sample degrees of freedom.
|
|||
|
|
Defaults to `Bessel's correction`_, ``correction=1``.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
Previously this argument was called ``unbiased`` and was a boolean
|
|||
|
|
with ``True`` corresponding to ``correction=1`` and ``False`` being
|
|||
|
|
``correction=0``.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor(
|
|||
|
|
... [[ 0.2035, 1.2959, 1.8101, -0.4644],
|
|||
|
|
... [ 1.5027, -0.3270, 0.5905, 0.6538],
|
|||
|
|
... [-1.5745, 1.3330, -0.5596, -0.6548],
|
|||
|
|
... [ 0.1264, -0.5080, 1.6420, 0.1992]])
|
|||
|
|
>>> torch.var(a, dim=1, keepdim=True)
|
|||
|
|
tensor([[1.0631],
|
|||
|
|
[0.5590],
|
|||
|
|
[1.4893],
|
|||
|
|
[0.8258]])
|
|||
|
|
|
|||
|
|
.. _Bessel's correction: https://en.wikipedia.org/wiki/Bessel%27s_correction
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def var(input: Tensor, unbiased: _bool = True) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
var(input, dim=None, *, correction=1, keepdim=False, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Calculates the variance over the dimensions specified by :attr:`dim`. :attr:`dim`
|
|||
|
|
can be a single dimension, list of dimensions, or ``None`` to reduce over all
|
|||
|
|
dimensions.
|
|||
|
|
|
|||
|
|
The variance (:math:`\sigma^2`) is calculated as
|
|||
|
|
|
|||
|
|
.. math:: \sigma^2 = \frac{1}{\max(0,~N - \delta N)}\sum_{i=0}^{N-1}(x_i-\bar{x})^2
|
|||
|
|
|
|||
|
|
where :math:`x` is the sample set of elements, :math:`\bar{x}` is the
|
|||
|
|
sample mean, :math:`N` is the number of samples and :math:`\delta N` is
|
|||
|
|
the :attr:`correction`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
dim (int or tuple of ints, optional): the dimension or dimensions to reduce.
|
|||
|
|
If ``None``, all dimensions are reduced.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
correction (int): difference between the sample size and sample degrees of freedom.
|
|||
|
|
Defaults to `Bessel's correction`_, ``correction=1``.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
Previously this argument was called ``unbiased`` and was a boolean
|
|||
|
|
with ``True`` corresponding to ``correction=1`` and ``False`` being
|
|||
|
|
``correction=0``.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor(
|
|||
|
|
... [[ 0.2035, 1.2959, 1.8101, -0.4644],
|
|||
|
|
... [ 1.5027, -0.3270, 0.5905, 0.6538],
|
|||
|
|
... [-1.5745, 1.3330, -0.5596, -0.6548],
|
|||
|
|
... [ 0.1264, -0.5080, 1.6420, 0.1992]])
|
|||
|
|
>>> torch.var(a, dim=1, keepdim=True)
|
|||
|
|
tensor([[1.0631],
|
|||
|
|
[0.5590],
|
|||
|
|
[1.4893],
|
|||
|
|
[0.8258]])
|
|||
|
|
|
|||
|
|
.. _Bessel's correction: https://en.wikipedia.org/wiki/Bessel%27s_correction
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def var(input: Tensor, dim: Sequence[Union[str, ellipsis, None]], *, correction: Optional[Union[Number, _complex]] = None, keepdim: _bool = False, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
var(input, dim=None, *, correction=1, keepdim=False, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Calculates the variance over the dimensions specified by :attr:`dim`. :attr:`dim`
|
|||
|
|
can be a single dimension, list of dimensions, or ``None`` to reduce over all
|
|||
|
|
dimensions.
|
|||
|
|
|
|||
|
|
The variance (:math:`\sigma^2`) is calculated as
|
|||
|
|
|
|||
|
|
.. math:: \sigma^2 = \frac{1}{\max(0,~N - \delta N)}\sum_{i=0}^{N-1}(x_i-\bar{x})^2
|
|||
|
|
|
|||
|
|
where :math:`x` is the sample set of elements, :math:`\bar{x}` is the
|
|||
|
|
sample mean, :math:`N` is the number of samples and :math:`\delta N` is
|
|||
|
|
the :attr:`correction`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
dim (int or tuple of ints, optional): the dimension or dimensions to reduce.
|
|||
|
|
If ``None``, all dimensions are reduced.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
correction (int): difference between the sample size and sample degrees of freedom.
|
|||
|
|
Defaults to `Bessel's correction`_, ``correction=1``.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
Previously this argument was called ``unbiased`` and was a boolean
|
|||
|
|
with ``True`` corresponding to ``correction=1`` and ``False`` being
|
|||
|
|
``correction=0``.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor(
|
|||
|
|
... [[ 0.2035, 1.2959, 1.8101, -0.4644],
|
|||
|
|
... [ 1.5027, -0.3270, 0.5905, 0.6538],
|
|||
|
|
... [-1.5745, 1.3330, -0.5596, -0.6548],
|
|||
|
|
... [ 0.1264, -0.5080, 1.6420, 0.1992]])
|
|||
|
|
>>> torch.var(a, dim=1, keepdim=True)
|
|||
|
|
tensor([[1.0631],
|
|||
|
|
[0.5590],
|
|||
|
|
[1.4893],
|
|||
|
|
[0.8258]])
|
|||
|
|
|
|||
|
|
.. _Bessel's correction: https://en.wikipedia.org/wiki/Bessel%27s_correction
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def var(input: Tensor, dim: Sequence[Union[str, ellipsis, None]], unbiased: _bool = True, keepdim: _bool = False, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
var(input, dim=None, *, correction=1, keepdim=False, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Calculates the variance over the dimensions specified by :attr:`dim`. :attr:`dim`
|
|||
|
|
can be a single dimension, list of dimensions, or ``None`` to reduce over all
|
|||
|
|
dimensions.
|
|||
|
|
|
|||
|
|
The variance (:math:`\sigma^2`) is calculated as
|
|||
|
|
|
|||
|
|
.. math:: \sigma^2 = \frac{1}{\max(0,~N - \delta N)}\sum_{i=0}^{N-1}(x_i-\bar{x})^2
|
|||
|
|
|
|||
|
|
where :math:`x` is the sample set of elements, :math:`\bar{x}` is the
|
|||
|
|
sample mean, :math:`N` is the number of samples and :math:`\delta N` is
|
|||
|
|
the :attr:`correction`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
dim (int or tuple of ints, optional): the dimension or dimensions to reduce.
|
|||
|
|
If ``None``, all dimensions are reduced.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
correction (int): difference between the sample size and sample degrees of freedom.
|
|||
|
|
Defaults to `Bessel's correction`_, ``correction=1``.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
Previously this argument was called ``unbiased`` and was a boolean
|
|||
|
|
with ``True`` corresponding to ``correction=1`` and ``False`` being
|
|||
|
|
``correction=0``.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor(
|
|||
|
|
... [[ 0.2035, 1.2959, 1.8101, -0.4644],
|
|||
|
|
... [ 1.5027, -0.3270, 0.5905, 0.6538],
|
|||
|
|
... [-1.5745, 1.3330, -0.5596, -0.6548],
|
|||
|
|
... [ 0.1264, -0.5080, 1.6420, 0.1992]])
|
|||
|
|
>>> torch.var(a, dim=1, keepdim=True)
|
|||
|
|
tensor([[1.0631],
|
|||
|
|
[0.5590],
|
|||
|
|
[1.4893],
|
|||
|
|
[0.8258]])
|
|||
|
|
|
|||
|
|
.. _Bessel's correction: https://en.wikipedia.org/wiki/Bessel%27s_correction
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def var_mean(input: Tensor, dim: Optional[Union[_int, _size]], unbiased: _bool = True, keepdim: _bool = False) -> Tuple[Tensor, Tensor]:
|
|||
|
|
r"""
|
|||
|
|
var_mean(input, dim=None, *, correction=1, keepdim=False, out=None) -> (Tensor, Tensor)
|
|||
|
|
|
|||
|
|
Calculates the variance and mean over the dimensions specified by :attr:`dim`.
|
|||
|
|
:attr:`dim` can be a single dimension, list of dimensions, or ``None`` to
|
|||
|
|
reduce over all dimensions.
|
|||
|
|
|
|||
|
|
The variance (:math:`\sigma^2`) is calculated as
|
|||
|
|
|
|||
|
|
.. math:: \sigma^2 = \frac{1}{\max(0,~N - \delta N)}\sum_{i=0}^{N-1}(x_i-\bar{x})^2
|
|||
|
|
|
|||
|
|
where :math:`x` is the sample set of elements, :math:`\bar{x}` is the
|
|||
|
|
sample mean, :math:`N` is the number of samples and :math:`\delta N` is
|
|||
|
|
the :attr:`correction`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
dim (int or tuple of ints, optional): the dimension or dimensions to reduce.
|
|||
|
|
If ``None``, all dimensions are reduced.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
correction (int): difference between the sample size and sample degrees of freedom.
|
|||
|
|
Defaults to `Bessel's correction`_, ``correction=1``.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
Previously this argument was called ``unbiased`` and was a boolean
|
|||
|
|
with ``True`` corresponding to ``correction=1`` and ``False`` being
|
|||
|
|
``correction=0``.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A tuple (var, mean) containing the variance and mean.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor(
|
|||
|
|
... [[ 0.2035, 1.2959, 1.8101, -0.4644],
|
|||
|
|
... [ 1.5027, -0.3270, 0.5905, 0.6538],
|
|||
|
|
... [-1.5745, 1.3330, -0.5596, -0.6548],
|
|||
|
|
... [ 0.1264, -0.5080, 1.6420, 0.1992]])
|
|||
|
|
>>> torch.var_mean(a, dim=0, keepdim=True)
|
|||
|
|
(tensor([[1.5926, 1.0056, 1.2005, 0.3646]]),
|
|||
|
|
tensor([[ 0.0645, 0.4485, 0.8707, -0.0665]]))
|
|||
|
|
|
|||
|
|
.. _Bessel's correction: https://en.wikipedia.org/wiki/Bessel%27s_correction
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def var_mean(input: Tensor, dim: Optional[Union[_int, _size]] = None, *, correction: Optional[Union[Number, _complex]] = None, keepdim: _bool = False) -> Tuple[Tensor, Tensor]:
|
|||
|
|
r"""
|
|||
|
|
var_mean(input, dim=None, *, correction=1, keepdim=False, out=None) -> (Tensor, Tensor)
|
|||
|
|
|
|||
|
|
Calculates the variance and mean over the dimensions specified by :attr:`dim`.
|
|||
|
|
:attr:`dim` can be a single dimension, list of dimensions, or ``None`` to
|
|||
|
|
reduce over all dimensions.
|
|||
|
|
|
|||
|
|
The variance (:math:`\sigma^2`) is calculated as
|
|||
|
|
|
|||
|
|
.. math:: \sigma^2 = \frac{1}{\max(0,~N - \delta N)}\sum_{i=0}^{N-1}(x_i-\bar{x})^2
|
|||
|
|
|
|||
|
|
where :math:`x` is the sample set of elements, :math:`\bar{x}` is the
|
|||
|
|
sample mean, :math:`N` is the number of samples and :math:`\delta N` is
|
|||
|
|
the :attr:`correction`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
dim (int or tuple of ints, optional): the dimension or dimensions to reduce.
|
|||
|
|
If ``None``, all dimensions are reduced.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
correction (int): difference between the sample size and sample degrees of freedom.
|
|||
|
|
Defaults to `Bessel's correction`_, ``correction=1``.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
Previously this argument was called ``unbiased`` and was a boolean
|
|||
|
|
with ``True`` corresponding to ``correction=1`` and ``False`` being
|
|||
|
|
``correction=0``.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A tuple (var, mean) containing the variance and mean.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor(
|
|||
|
|
... [[ 0.2035, 1.2959, 1.8101, -0.4644],
|
|||
|
|
... [ 1.5027, -0.3270, 0.5905, 0.6538],
|
|||
|
|
... [-1.5745, 1.3330, -0.5596, -0.6548],
|
|||
|
|
... [ 0.1264, -0.5080, 1.6420, 0.1992]])
|
|||
|
|
>>> torch.var_mean(a, dim=0, keepdim=True)
|
|||
|
|
(tensor([[1.5926, 1.0056, 1.2005, 0.3646]]),
|
|||
|
|
tensor([[ 0.0645, 0.4485, 0.8707, -0.0665]]))
|
|||
|
|
|
|||
|
|
.. _Bessel's correction: https://en.wikipedia.org/wiki/Bessel%27s_correction
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def var_mean(input: Tensor, unbiased: _bool = True) -> Tuple[Tensor, Tensor]:
|
|||
|
|
r"""
|
|||
|
|
var_mean(input, dim=None, *, correction=1, keepdim=False, out=None) -> (Tensor, Tensor)
|
|||
|
|
|
|||
|
|
Calculates the variance and mean over the dimensions specified by :attr:`dim`.
|
|||
|
|
:attr:`dim` can be a single dimension, list of dimensions, or ``None`` to
|
|||
|
|
reduce over all dimensions.
|
|||
|
|
|
|||
|
|
The variance (:math:`\sigma^2`) is calculated as
|
|||
|
|
|
|||
|
|
.. math:: \sigma^2 = \frac{1}{\max(0,~N - \delta N)}\sum_{i=0}^{N-1}(x_i-\bar{x})^2
|
|||
|
|
|
|||
|
|
where :math:`x` is the sample set of elements, :math:`\bar{x}` is the
|
|||
|
|
sample mean, :math:`N` is the number of samples and :math:`\delta N` is
|
|||
|
|
the :attr:`correction`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
dim (int or tuple of ints, optional): the dimension or dimensions to reduce.
|
|||
|
|
If ``None``, all dimensions are reduced.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
correction (int): difference between the sample size and sample degrees of freedom.
|
|||
|
|
Defaults to `Bessel's correction`_, ``correction=1``.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
Previously this argument was called ``unbiased`` and was a boolean
|
|||
|
|
with ``True`` corresponding to ``correction=1`` and ``False`` being
|
|||
|
|
``correction=0``.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A tuple (var, mean) containing the variance and mean.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor(
|
|||
|
|
... [[ 0.2035, 1.2959, 1.8101, -0.4644],
|
|||
|
|
... [ 1.5027, -0.3270, 0.5905, 0.6538],
|
|||
|
|
... [-1.5745, 1.3330, -0.5596, -0.6548],
|
|||
|
|
... [ 0.1264, -0.5080, 1.6420, 0.1992]])
|
|||
|
|
>>> torch.var_mean(a, dim=0, keepdim=True)
|
|||
|
|
(tensor([[1.5926, 1.0056, 1.2005, 0.3646]]),
|
|||
|
|
tensor([[ 0.0645, 0.4485, 0.8707, -0.0665]]))
|
|||
|
|
|
|||
|
|
.. _Bessel's correction: https://en.wikipedia.org/wiki/Bessel%27s_correction
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def var_mean(input: Tensor, dim: Sequence[Union[str, ellipsis, None]], *, correction: Optional[Union[Number, _complex]] = None, keepdim: _bool = False) -> Tuple[Tensor, Tensor]:
|
|||
|
|
r"""
|
|||
|
|
var_mean(input, dim=None, *, correction=1, keepdim=False, out=None) -> (Tensor, Tensor)
|
|||
|
|
|
|||
|
|
Calculates the variance and mean over the dimensions specified by :attr:`dim`.
|
|||
|
|
:attr:`dim` can be a single dimension, list of dimensions, or ``None`` to
|
|||
|
|
reduce over all dimensions.
|
|||
|
|
|
|||
|
|
The variance (:math:`\sigma^2`) is calculated as
|
|||
|
|
|
|||
|
|
.. math:: \sigma^2 = \frac{1}{\max(0,~N - \delta N)}\sum_{i=0}^{N-1}(x_i-\bar{x})^2
|
|||
|
|
|
|||
|
|
where :math:`x` is the sample set of elements, :math:`\bar{x}` is the
|
|||
|
|
sample mean, :math:`N` is the number of samples and :math:`\delta N` is
|
|||
|
|
the :attr:`correction`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
dim (int or tuple of ints, optional): the dimension or dimensions to reduce.
|
|||
|
|
If ``None``, all dimensions are reduced.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
correction (int): difference between the sample size and sample degrees of freedom.
|
|||
|
|
Defaults to `Bessel's correction`_, ``correction=1``.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
Previously this argument was called ``unbiased`` and was a boolean
|
|||
|
|
with ``True`` corresponding to ``correction=1`` and ``False`` being
|
|||
|
|
``correction=0``.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A tuple (var, mean) containing the variance and mean.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor(
|
|||
|
|
... [[ 0.2035, 1.2959, 1.8101, -0.4644],
|
|||
|
|
... [ 1.5027, -0.3270, 0.5905, 0.6538],
|
|||
|
|
... [-1.5745, 1.3330, -0.5596, -0.6548],
|
|||
|
|
... [ 0.1264, -0.5080, 1.6420, 0.1992]])
|
|||
|
|
>>> torch.var_mean(a, dim=0, keepdim=True)
|
|||
|
|
(tensor([[1.5926, 1.0056, 1.2005, 0.3646]]),
|
|||
|
|
tensor([[ 0.0645, 0.4485, 0.8707, -0.0665]]))
|
|||
|
|
|
|||
|
|
.. _Bessel's correction: https://en.wikipedia.org/wiki/Bessel%27s_correction
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def var_mean(input: Tensor, dim: Sequence[Union[str, ellipsis, None]], unbiased: _bool = True, keepdim: _bool = False) -> Tuple[Tensor, Tensor]:
|
|||
|
|
r"""
|
|||
|
|
var_mean(input, dim=None, *, correction=1, keepdim=False, out=None) -> (Tensor, Tensor)
|
|||
|
|
|
|||
|
|
Calculates the variance and mean over the dimensions specified by :attr:`dim`.
|
|||
|
|
:attr:`dim` can be a single dimension, list of dimensions, or ``None`` to
|
|||
|
|
reduce over all dimensions.
|
|||
|
|
|
|||
|
|
The variance (:math:`\sigma^2`) is calculated as
|
|||
|
|
|
|||
|
|
.. math:: \sigma^2 = \frac{1}{\max(0,~N - \delta N)}\sum_{i=0}^{N-1}(x_i-\bar{x})^2
|
|||
|
|
|
|||
|
|
where :math:`x` is the sample set of elements, :math:`\bar{x}` is the
|
|||
|
|
sample mean, :math:`N` is the number of samples and :math:`\delta N` is
|
|||
|
|
the :attr:`correction`.
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
If :attr:`keepdim` is ``True``, the output tensor is of the same size
|
|||
|
|
as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1.
|
|||
|
|
Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the
|
|||
|
|
output tensor having 1 (or ``len(dim)``) fewer dimension(s).
|
|||
|
|
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
dim (int or tuple of ints, optional): the dimension or dimensions to reduce.
|
|||
|
|
If ``None``, all dimensions are reduced.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
correction (int): difference between the sample size and sample degrees of freedom.
|
|||
|
|
Defaults to `Bessel's correction`_, ``correction=1``.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 2.0
|
|||
|
|
Previously this argument was called ``unbiased`` and was a boolean
|
|||
|
|
with ``True`` corresponding to ``correction=1`` and ``False`` being
|
|||
|
|
``correction=0``.
|
|||
|
|
keepdim (bool): whether the output tensor has :attr:`dim` retained or not.
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
A tuple (var, mean) containing the variance and mean.
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor(
|
|||
|
|
... [[ 0.2035, 1.2959, 1.8101, -0.4644],
|
|||
|
|
... [ 1.5027, -0.3270, 0.5905, 0.6538],
|
|||
|
|
... [-1.5745, 1.3330, -0.5596, -0.6548],
|
|||
|
|
... [ 0.1264, -0.5080, 1.6420, 0.1992]])
|
|||
|
|
>>> torch.var_mean(a, dim=0, keepdim=True)
|
|||
|
|
(tensor([[1.5926, 1.0056, 1.2005, 0.3646]]),
|
|||
|
|
tensor([[ 0.0645, 0.4485, 0.8707, -0.0665]]))
|
|||
|
|
|
|||
|
|
.. _Bessel's correction: https://en.wikipedia.org/wiki/Bessel%27s_correction
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def vdot(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
vdot(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Computes the dot product of two 1D vectors along a dimension.
|
|||
|
|
|
|||
|
|
In symbols, this function computes
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
|
|||
|
|
\sum_{i=1}^n \overline{x_i}y_i.
|
|||
|
|
|
|||
|
|
where :math:`\overline{x_i}` denotes the conjugate for complex
|
|||
|
|
vectors, and it is the identity for real vectors.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
|
|||
|
|
Unlike NumPy's vdot, torch.vdot intentionally only supports computing the dot product
|
|||
|
|
of two 1D tensors with the same number of elements.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
|
|||
|
|
:func:`torch.linalg.vecdot` computes the dot product of two batches of vectors along a dimension.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): first tensor in the dot product, must be 1D. Its conjugate is used if it's complex.
|
|||
|
|
other (Tensor): second tensor in the dot product, must be 1D.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
|
|||
|
|
.. note:: out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.vdot(torch.tensor([2, 3]), torch.tensor([2, 1]))
|
|||
|
|
tensor(7)
|
|||
|
|
>>> a = torch.tensor((1 +2j, 3 - 1j))
|
|||
|
|
>>> b = torch.tensor((2 +1j, 4 - 0j))
|
|||
|
|
>>> torch.vdot(a, b)
|
|||
|
|
tensor([16.+1.j])
|
|||
|
|
>>> torch.vdot(b, a)
|
|||
|
|
tensor([16.-1.j])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def view_as_complex(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
view_as_complex(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a view of :attr:`input` as a complex tensor. For an input complex
|
|||
|
|
tensor of :attr:`size` :math:`m1, m2, \dots, mi, 2`, this function returns a
|
|||
|
|
new complex tensor of :attr:`size` :math:`m1, m2, \dots, mi` where the last
|
|||
|
|
dimension of the input tensor is expected to represent the real and imaginary
|
|||
|
|
components of complex numbers.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
:func:`view_as_complex` is only supported for tensors with
|
|||
|
|
:class:`torch.dtype` ``torch.float64`` and ``torch.float32``. The input is
|
|||
|
|
expected to have the last dimension of :attr:`size` 2. In addition, the
|
|||
|
|
tensor must have a `stride` of 1 for its last dimension. The strides of all
|
|||
|
|
other dimensions must be even numbers.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x=torch.randn(4, 2)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 1.6116, -0.5772],
|
|||
|
|
[-1.4606, -0.9120],
|
|||
|
|
[ 0.0786, -1.7497],
|
|||
|
|
[-0.6561, -1.6623]])
|
|||
|
|
>>> torch.view_as_complex(x)
|
|||
|
|
tensor([(1.6116-0.5772j), (-1.4606-0.9120j), (0.0786-1.7497j), (-0.6561-1.6623j)])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def view_as_complex_copy(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.view_as_complex`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def view_as_real(input: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
view_as_real(input) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a view of :attr:`input` as a real tensor. For an input complex tensor of
|
|||
|
|
:attr:`size` :math:`m1, m2, \dots, mi`, this function returns a new
|
|||
|
|
real tensor of size :math:`m1, m2, \dots, mi, 2`, where the last dimension of size 2
|
|||
|
|
represents the real and imaginary components of complex numbers.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
:func:`view_as_real` is only supported for tensors with ``complex dtypes``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the input tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x=torch.randn(4, dtype=torch.cfloat)
|
|||
|
|
>>> x
|
|||
|
|
tensor([(0.4737-0.3839j), (-0.2098-0.6699j), (0.3470-0.9451j), (-0.5174-1.3136j)])
|
|||
|
|
>>> torch.view_as_real(x)
|
|||
|
|
tensor([[ 0.4737, -0.3839],
|
|||
|
|
[-0.2098, -0.6699],
|
|||
|
|
[ 0.3470, -0.9451],
|
|||
|
|
[-0.5174, -1.3136]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def view_as_real_copy(input: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.view_as_real`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def view_copy(input: Tensor, dtype: _dtype, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.view`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def view_copy(input: Tensor, size: Sequence[Union[_int, SymInt]], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
Performs the same operation as :func:`torch.view`, but all output tensors
|
|||
|
|
are freshly created instead of aliasing the input.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def vsplit(input: Tensor, sections: _int) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
vsplit(input, indices_or_sections) -> List of Tensors
|
|||
|
|
|
|||
|
|
Splits :attr:`input`, a tensor with two or more dimensions, into multiple tensors
|
|||
|
|
vertically according to :attr:`indices_or_sections`. Each split is a view of
|
|||
|
|
:attr:`input`.
|
|||
|
|
|
|||
|
|
This is equivalent to calling torch.tensor_split(input, indices_or_sections, dim=0)
|
|||
|
|
(the split dimension is 0), except that if :attr:`indices_or_sections` is an integer
|
|||
|
|
it must evenly divide the split dimension or a runtime error will be thrown.
|
|||
|
|
|
|||
|
|
This function is based on NumPy's :func:`numpy.vsplit`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): tensor to split.
|
|||
|
|
indices_or_sections (int or list or tuple of ints): See argument in :func:`torch.tensor_split`.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
>>> t = torch.arange(16.0).reshape(4,4)
|
|||
|
|
>>> t
|
|||
|
|
tensor([[ 0., 1., 2., 3.],
|
|||
|
|
[ 4., 5., 6., 7.],
|
|||
|
|
[ 8., 9., 10., 11.],
|
|||
|
|
[12., 13., 14., 15.]])
|
|||
|
|
>>> torch.vsplit(t, 2)
|
|||
|
|
(tensor([[0., 1., 2., 3.],
|
|||
|
|
[4., 5., 6., 7.]]),
|
|||
|
|
tensor([[ 8., 9., 10., 11.],
|
|||
|
|
[12., 13., 14., 15.]]))
|
|||
|
|
>>> torch.vsplit(t, [3, 6])
|
|||
|
|
(tensor([[ 0., 1., 2., 3.],
|
|||
|
|
[ 4., 5., 6., 7.],
|
|||
|
|
[ 8., 9., 10., 11.]]),
|
|||
|
|
tensor([[12., 13., 14., 15.]]),
|
|||
|
|
tensor([], size=(0, 4)))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def vsplit(input: Tensor, indices: _size) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
vsplit(input, indices_or_sections) -> List of Tensors
|
|||
|
|
|
|||
|
|
Splits :attr:`input`, a tensor with two or more dimensions, into multiple tensors
|
|||
|
|
vertically according to :attr:`indices_or_sections`. Each split is a view of
|
|||
|
|
:attr:`input`.
|
|||
|
|
|
|||
|
|
This is equivalent to calling torch.tensor_split(input, indices_or_sections, dim=0)
|
|||
|
|
(the split dimension is 0), except that if :attr:`indices_or_sections` is an integer
|
|||
|
|
it must evenly divide the split dimension or a runtime error will be thrown.
|
|||
|
|
|
|||
|
|
This function is based on NumPy's :func:`numpy.vsplit`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): tensor to split.
|
|||
|
|
indices_or_sections (int or list or tuple of ints): See argument in :func:`torch.tensor_split`.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
>>> t = torch.arange(16.0).reshape(4,4)
|
|||
|
|
>>> t
|
|||
|
|
tensor([[ 0., 1., 2., 3.],
|
|||
|
|
[ 4., 5., 6., 7.],
|
|||
|
|
[ 8., 9., 10., 11.],
|
|||
|
|
[12., 13., 14., 15.]])
|
|||
|
|
>>> torch.vsplit(t, 2)
|
|||
|
|
(tensor([[0., 1., 2., 3.],
|
|||
|
|
[4., 5., 6., 7.]]),
|
|||
|
|
tensor([[ 8., 9., 10., 11.],
|
|||
|
|
[12., 13., 14., 15.]]))
|
|||
|
|
>>> torch.vsplit(t, [3, 6])
|
|||
|
|
(tensor([[ 0., 1., 2., 3.],
|
|||
|
|
[ 4., 5., 6., 7.],
|
|||
|
|
[ 8., 9., 10., 11.]]),
|
|||
|
|
tensor([[12., 13., 14., 15.]]),
|
|||
|
|
tensor([], size=(0, 4)))
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def vstack(tensors: Union[Tuple[Tensor, ...], List[Tensor]], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
vstack(tensors, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Stack tensors in sequence vertically (row wise).
|
|||
|
|
|
|||
|
|
This is equivalent to concatenation along the first axis after all 1-D tensors have been reshaped by :func:`torch.atleast_2d`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
tensors (sequence of Tensors): sequence of tensors to concatenate
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> a = torch.tensor([1, 2, 3])
|
|||
|
|
>>> b = torch.tensor([4, 5, 6])
|
|||
|
|
>>> torch.vstack((a,b))
|
|||
|
|
tensor([[1, 2, 3],
|
|||
|
|
[4, 5, 6]])
|
|||
|
|
>>> a = torch.tensor([[1],[2],[3]])
|
|||
|
|
>>> b = torch.tensor([[4],[5],[6]])
|
|||
|
|
>>> torch.vstack((a,b))
|
|||
|
|
tensor([[1],
|
|||
|
|
[2],
|
|||
|
|
[3],
|
|||
|
|
[4],
|
|||
|
|
[5],
|
|||
|
|
[6]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def where(condition: Tensor) -> Tuple[Tensor, ...]:
|
|||
|
|
r"""
|
|||
|
|
where(condition, input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Return a tensor of elements selected from either :attr:`input` or :attr:`other`, depending on :attr:`condition`.
|
|||
|
|
|
|||
|
|
The operation is defined as:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \begin{cases}
|
|||
|
|
\text{input}_i & \text{if } \text{condition}_i \\
|
|||
|
|
\text{other}_i & \text{otherwise} \\
|
|||
|
|
\end{cases}
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
The tensors :attr:`condition`, :attr:`input`, :attr:`other` must be :ref:`broadcastable <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
condition (BoolTensor): When True (nonzero), yield input, otherwise yield other
|
|||
|
|
input (Tensor or Scalar): value (if :attr:`input` is a scalar) or values selected at indices
|
|||
|
|
where :attr:`condition` is ``True``
|
|||
|
|
other (Tensor or Scalar): value (if :attr:`other` is a scalar) or values selected at indices
|
|||
|
|
where :attr:`condition` is ``False``
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A tensor of shape equal to the broadcasted shape of :attr:`condition`, :attr:`input`, :attr:`other`
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(3, 2)
|
|||
|
|
>>> y = torch.ones(3, 2)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[-0.4620, 0.3139],
|
|||
|
|
[ 0.3898, -0.7197],
|
|||
|
|
[ 0.0478, -0.1657]])
|
|||
|
|
>>> torch.where(x > 0, 1.0, 0.0)
|
|||
|
|
tensor([[0., 1.],
|
|||
|
|
[1., 0.],
|
|||
|
|
[1., 0.]])
|
|||
|
|
>>> torch.where(x > 0, x, y)
|
|||
|
|
tensor([[ 1.0000, 0.3139],
|
|||
|
|
[ 0.3898, 1.0000],
|
|||
|
|
[ 0.0478, 1.0000]])
|
|||
|
|
>>> x = torch.randn(2, 2, dtype=torch.double)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 1.0779, 0.0383],
|
|||
|
|
[-0.8785, -1.1089]], dtype=torch.float64)
|
|||
|
|
>>> torch.where(x > 0, x, 0.)
|
|||
|
|
tensor([[1.0779, 0.0383],
|
|||
|
|
[0.0000, 0.0000]], dtype=torch.float64)
|
|||
|
|
|
|||
|
|
.. function:: where(condition) -> tuple of LongTensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
``torch.where(condition)`` is identical to
|
|||
|
|
``torch.nonzero(condition, as_tuple=True)``.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
See also :func:`torch.nonzero`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def where(condition: Tensor, input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
where(condition, input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Return a tensor of elements selected from either :attr:`input` or :attr:`other`, depending on :attr:`condition`.
|
|||
|
|
|
|||
|
|
The operation is defined as:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \begin{cases}
|
|||
|
|
\text{input}_i & \text{if } \text{condition}_i \\
|
|||
|
|
\text{other}_i & \text{otherwise} \\
|
|||
|
|
\end{cases}
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
The tensors :attr:`condition`, :attr:`input`, :attr:`other` must be :ref:`broadcastable <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
condition (BoolTensor): When True (nonzero), yield input, otherwise yield other
|
|||
|
|
input (Tensor or Scalar): value (if :attr:`input` is a scalar) or values selected at indices
|
|||
|
|
where :attr:`condition` is ``True``
|
|||
|
|
other (Tensor or Scalar): value (if :attr:`other` is a scalar) or values selected at indices
|
|||
|
|
where :attr:`condition` is ``False``
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A tensor of shape equal to the broadcasted shape of :attr:`condition`, :attr:`input`, :attr:`other`
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(3, 2)
|
|||
|
|
>>> y = torch.ones(3, 2)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[-0.4620, 0.3139],
|
|||
|
|
[ 0.3898, -0.7197],
|
|||
|
|
[ 0.0478, -0.1657]])
|
|||
|
|
>>> torch.where(x > 0, 1.0, 0.0)
|
|||
|
|
tensor([[0., 1.],
|
|||
|
|
[1., 0.],
|
|||
|
|
[1., 0.]])
|
|||
|
|
>>> torch.where(x > 0, x, y)
|
|||
|
|
tensor([[ 1.0000, 0.3139],
|
|||
|
|
[ 0.3898, 1.0000],
|
|||
|
|
[ 0.0478, 1.0000]])
|
|||
|
|
>>> x = torch.randn(2, 2, dtype=torch.double)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 1.0779, 0.0383],
|
|||
|
|
[-0.8785, -1.1089]], dtype=torch.float64)
|
|||
|
|
>>> torch.where(x > 0, x, 0.)
|
|||
|
|
tensor([[1.0779, 0.0383],
|
|||
|
|
[0.0000, 0.0000]], dtype=torch.float64)
|
|||
|
|
|
|||
|
|
.. function:: where(condition) -> tuple of LongTensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
``torch.where(condition)`` is identical to
|
|||
|
|
``torch.nonzero(condition, as_tuple=True)``.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
See also :func:`torch.nonzero`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def where(condition: Tensor, self: Union[Number, _complex], other: Tensor) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
where(condition, input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Return a tensor of elements selected from either :attr:`input` or :attr:`other`, depending on :attr:`condition`.
|
|||
|
|
|
|||
|
|
The operation is defined as:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \begin{cases}
|
|||
|
|
\text{input}_i & \text{if } \text{condition}_i \\
|
|||
|
|
\text{other}_i & \text{otherwise} \\
|
|||
|
|
\end{cases}
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
The tensors :attr:`condition`, :attr:`input`, :attr:`other` must be :ref:`broadcastable <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
condition (BoolTensor): When True (nonzero), yield input, otherwise yield other
|
|||
|
|
input (Tensor or Scalar): value (if :attr:`input` is a scalar) or values selected at indices
|
|||
|
|
where :attr:`condition` is ``True``
|
|||
|
|
other (Tensor or Scalar): value (if :attr:`other` is a scalar) or values selected at indices
|
|||
|
|
where :attr:`condition` is ``False``
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A tensor of shape equal to the broadcasted shape of :attr:`condition`, :attr:`input`, :attr:`other`
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(3, 2)
|
|||
|
|
>>> y = torch.ones(3, 2)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[-0.4620, 0.3139],
|
|||
|
|
[ 0.3898, -0.7197],
|
|||
|
|
[ 0.0478, -0.1657]])
|
|||
|
|
>>> torch.where(x > 0, 1.0, 0.0)
|
|||
|
|
tensor([[0., 1.],
|
|||
|
|
[1., 0.],
|
|||
|
|
[1., 0.]])
|
|||
|
|
>>> torch.where(x > 0, x, y)
|
|||
|
|
tensor([[ 1.0000, 0.3139],
|
|||
|
|
[ 0.3898, 1.0000],
|
|||
|
|
[ 0.0478, 1.0000]])
|
|||
|
|
>>> x = torch.randn(2, 2, dtype=torch.double)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 1.0779, 0.0383],
|
|||
|
|
[-0.8785, -1.1089]], dtype=torch.float64)
|
|||
|
|
>>> torch.where(x > 0, x, 0.)
|
|||
|
|
tensor([[1.0779, 0.0383],
|
|||
|
|
[0.0000, 0.0000]], dtype=torch.float64)
|
|||
|
|
|
|||
|
|
.. function:: where(condition) -> tuple of LongTensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
``torch.where(condition)`` is identical to
|
|||
|
|
``torch.nonzero(condition, as_tuple=True)``.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
See also :func:`torch.nonzero`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def where(condition: Tensor, input: Tensor, other: Union[Number, _complex]) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
where(condition, input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Return a tensor of elements selected from either :attr:`input` or :attr:`other`, depending on :attr:`condition`.
|
|||
|
|
|
|||
|
|
The operation is defined as:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \begin{cases}
|
|||
|
|
\text{input}_i & \text{if } \text{condition}_i \\
|
|||
|
|
\text{other}_i & \text{otherwise} \\
|
|||
|
|
\end{cases}
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
The tensors :attr:`condition`, :attr:`input`, :attr:`other` must be :ref:`broadcastable <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
condition (BoolTensor): When True (nonzero), yield input, otherwise yield other
|
|||
|
|
input (Tensor or Scalar): value (if :attr:`input` is a scalar) or values selected at indices
|
|||
|
|
where :attr:`condition` is ``True``
|
|||
|
|
other (Tensor or Scalar): value (if :attr:`other` is a scalar) or values selected at indices
|
|||
|
|
where :attr:`condition` is ``False``
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A tensor of shape equal to the broadcasted shape of :attr:`condition`, :attr:`input`, :attr:`other`
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(3, 2)
|
|||
|
|
>>> y = torch.ones(3, 2)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[-0.4620, 0.3139],
|
|||
|
|
[ 0.3898, -0.7197],
|
|||
|
|
[ 0.0478, -0.1657]])
|
|||
|
|
>>> torch.where(x > 0, 1.0, 0.0)
|
|||
|
|
tensor([[0., 1.],
|
|||
|
|
[1., 0.],
|
|||
|
|
[1., 0.]])
|
|||
|
|
>>> torch.where(x > 0, x, y)
|
|||
|
|
tensor([[ 1.0000, 0.3139],
|
|||
|
|
[ 0.3898, 1.0000],
|
|||
|
|
[ 0.0478, 1.0000]])
|
|||
|
|
>>> x = torch.randn(2, 2, dtype=torch.double)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 1.0779, 0.0383],
|
|||
|
|
[-0.8785, -1.1089]], dtype=torch.float64)
|
|||
|
|
>>> torch.where(x > 0, x, 0.)
|
|||
|
|
tensor([[1.0779, 0.0383],
|
|||
|
|
[0.0000, 0.0000]], dtype=torch.float64)
|
|||
|
|
|
|||
|
|
.. function:: where(condition) -> tuple of LongTensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
``torch.where(condition)`` is identical to
|
|||
|
|
``torch.nonzero(condition, as_tuple=True)``.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
See also :func:`torch.nonzero`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def where(condition: Tensor, self: Union[Number, _complex], other: Union[Number, _complex]) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
where(condition, input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Return a tensor of elements selected from either :attr:`input` or :attr:`other`, depending on :attr:`condition`.
|
|||
|
|
|
|||
|
|
The operation is defined as:
|
|||
|
|
|
|||
|
|
.. math::
|
|||
|
|
\text{out}_i = \begin{cases}
|
|||
|
|
\text{input}_i & \text{if } \text{condition}_i \\
|
|||
|
|
\text{other}_i & \text{otherwise} \\
|
|||
|
|
\end{cases}
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
The tensors :attr:`condition`, :attr:`input`, :attr:`other` must be :ref:`broadcastable <broadcasting-semantics>`.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
condition (BoolTensor): When True (nonzero), yield input, otherwise yield other
|
|||
|
|
input (Tensor or Scalar): value (if :attr:`input` is a scalar) or values selected at indices
|
|||
|
|
where :attr:`condition` is ``True``
|
|||
|
|
other (Tensor or Scalar): value (if :attr:`other` is a scalar) or values selected at indices
|
|||
|
|
where :attr:`condition` is ``False``
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
Tensor: A tensor of shape equal to the broadcasted shape of :attr:`condition`, :attr:`input`, :attr:`other`
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> x = torch.randn(3, 2)
|
|||
|
|
>>> y = torch.ones(3, 2)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[-0.4620, 0.3139],
|
|||
|
|
[ 0.3898, -0.7197],
|
|||
|
|
[ 0.0478, -0.1657]])
|
|||
|
|
>>> torch.where(x > 0, 1.0, 0.0)
|
|||
|
|
tensor([[0., 1.],
|
|||
|
|
[1., 0.],
|
|||
|
|
[1., 0.]])
|
|||
|
|
>>> torch.where(x > 0, x, y)
|
|||
|
|
tensor([[ 1.0000, 0.3139],
|
|||
|
|
[ 0.3898, 1.0000],
|
|||
|
|
[ 0.0478, 1.0000]])
|
|||
|
|
>>> x = torch.randn(2, 2, dtype=torch.double)
|
|||
|
|
>>> x
|
|||
|
|
tensor([[ 1.0779, 0.0383],
|
|||
|
|
[-0.8785, -1.1089]], dtype=torch.float64)
|
|||
|
|
>>> torch.where(x > 0, x, 0.)
|
|||
|
|
tensor([[1.0779, 0.0383],
|
|||
|
|
[0.0000, 0.0000]], dtype=torch.float64)
|
|||
|
|
|
|||
|
|
.. function:: where(condition) -> tuple of LongTensor
|
|||
|
|
:noindex:
|
|||
|
|
|
|||
|
|
``torch.where(condition)`` is identical to
|
|||
|
|
``torch.nonzero(condition, as_tuple=True)``.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
See also :func:`torch.nonzero`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def xlogy(input: Tensor, other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
xlogy(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.special.xlogy`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def xlogy(self: Union[Number, _complex], other: Tensor, *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
xlogy(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.special.xlogy`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def xlogy(input: Tensor, other: Union[Number, _complex], *, out: Optional[Tensor] = None) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
xlogy(input, other, *, out=None) -> Tensor
|
|||
|
|
|
|||
|
|
Alias for :func:`torch.special.xlogy`.
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def xlogy_(input: Tensor, other: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def xlogy_(input: Tensor, other: Union[Number, _complex]) -> Tensor: ...
|
|||
|
|
def zero_(input: Tensor) -> Tensor: ...
|
|||
|
|
@overload
|
|||
|
|
def zeros(size: Sequence[Union[_int, SymInt]], *, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
zeros(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with the scalar value `0`, with the shape defined
|
|||
|
|
by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.zeros(2, 3)
|
|||
|
|
tensor([[ 0., 0., 0.],
|
|||
|
|
[ 0., 0., 0.]])
|
|||
|
|
|
|||
|
|
>>> torch.zeros(5)
|
|||
|
|
tensor([ 0., 0., 0., 0., 0.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def zeros(*size: _int, out: Optional[Tensor] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
zeros(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with the scalar value `0`, with the shape defined
|
|||
|
|
by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.zeros(2, 3)
|
|||
|
|
tensor([[ 0., 0., 0.],
|
|||
|
|
[ 0., 0., 0.]])
|
|||
|
|
|
|||
|
|
>>> torch.zeros(5)
|
|||
|
|
tensor([ 0., 0., 0., 0., 0.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def zeros(size: _size, *, names: Optional[Sequence[Union[str, ellipsis, None]]], dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
zeros(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with the scalar value `0`, with the shape defined
|
|||
|
|
by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.zeros(2, 3)
|
|||
|
|
tensor([[ 0., 0., 0.],
|
|||
|
|
[ 0., 0., 0.]])
|
|||
|
|
|
|||
|
|
>>> torch.zeros(5)
|
|||
|
|
tensor([ 0., 0., 0., 0., 0.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
@overload
|
|||
|
|
def zeros(*size: _int, names: Optional[Sequence[Union[str, ellipsis, None]]], dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
zeros(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with the scalar value `0`, with the shape defined
|
|||
|
|
by the variable argument :attr:`size`.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
size (int...): a sequence of integers defining the shape of the output tensor.
|
|||
|
|
Can be a variable number of arguments or a collection like a list or tuple.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
out (Tensor, optional): the output tensor.
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
|
|||
|
|
Default: if ``None``, uses a global default (see :func:`torch.set_default_dtype`).
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
|
|||
|
|
Default: ``torch.strided``.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, uses the current device for the default tensor type
|
|||
|
|
(see :func:`torch.set_default_device`). :attr:`device` will be the CPU
|
|||
|
|
for CPU tensor types and the current CUDA device for CUDA tensor types.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> torch.zeros(2, 3)
|
|||
|
|
tensor([[ 0., 0., 0.],
|
|||
|
|
[ 0., 0., 0.]])
|
|||
|
|
|
|||
|
|
>>> torch.zeros(5)
|
|||
|
|
tensor([ 0., 0., 0., 0., 0.])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
def zeros_like(input: Tensor, *, memory_format: Optional[memory_format] = None, dtype: Optional[_dtype] = None, layout: Optional[_layout] = None, device: Optional[Optional[DeviceLikeType]] = None, pin_memory: Optional[_bool] = False, requires_grad: Optional[_bool] = False) -> Tensor:
|
|||
|
|
r"""
|
|||
|
|
zeros_like(input, *, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format) -> Tensor
|
|||
|
|
|
|||
|
|
Returns a tensor filled with the scalar value `0`, with the same size as
|
|||
|
|
:attr:`input`. ``torch.zeros_like(input)`` is equivalent to
|
|||
|
|
``torch.zeros(input.size(), dtype=input.dtype, layout=input.layout, device=input.device)``.
|
|||
|
|
|
|||
|
|
.. warning::
|
|||
|
|
As of 0.4, this function does not support an :attr:`out` keyword. As an alternative,
|
|||
|
|
the old ``torch.zeros_like(input, out=output)`` is equivalent to
|
|||
|
|
``torch.zeros(input.size(), out=output)``.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
input (Tensor): the size of :attr:`input` will determine size of the output tensor.
|
|||
|
|
|
|||
|
|
Keyword args:
|
|||
|
|
dtype (:class:`torch.dtype`, optional): the desired data type of returned Tensor.
|
|||
|
|
Default: if ``None``, defaults to the dtype of :attr:`input`.
|
|||
|
|
layout (:class:`torch.layout`, optional): the desired layout of returned tensor.
|
|||
|
|
Default: if ``None``, defaults to the layout of :attr:`input`.
|
|||
|
|
device (:class:`torch.device`, optional): the desired device of returned tensor.
|
|||
|
|
Default: if ``None``, defaults to the device of :attr:`input`.
|
|||
|
|
requires_grad (bool, optional): If autograd should record operations on the
|
|||
|
|
returned tensor. Default: ``False``.
|
|||
|
|
memory_format (:class:`torch.memory_format`, optional): the desired memory format of
|
|||
|
|
returned Tensor. Default: ``torch.preserve_format``.
|
|||
|
|
|
|||
|
|
Example::
|
|||
|
|
|
|||
|
|
>>> input = torch.empty(2, 3)
|
|||
|
|
>>> torch.zeros_like(input)
|
|||
|
|
tensor([[ 0., 0., 0.],
|
|||
|
|
[ 0., 0., 0.]])
|
|||
|
|
"""
|
|||
|
|
...
|
|||
|
|
|
|||
|
|
__all__ = ['__and__', '__lshift__', '__or__', '__rshift__', '__xor__', '_adaptive_avg_pool2d',
|
|||
|
|
'_adaptive_avg_pool3d', '_add_batch_dim', '_add_relu', '_add_relu_', '_addmm_activation',
|
|||
|
|
'_aminmax', '_amp_foreach_non_finite_check_and_unscale_', '_amp_update_scale_', '_assert_async',
|
|||
|
|
'_assert_scalar', '_assert_tensor_metadata', '_batch_norm_impl_index', '_cast_Byte', '_cast_Char',
|
|||
|
|
'_cast_Double', '_cast_Float', '_cast_Half', '_cast_Int', '_cast_Long', '_cast_Short',
|
|||
|
|
'_choose_qparams_per_tensor', '_chunk_cat', '_coalesce', '_compute_linear_combination', '_conj',
|
|||
|
|
'_conj_copy', '_conj_physical', '_convert_indices_from_coo_to_csr',
|
|||
|
|
'_convert_indices_from_csr_to_coo', '_convert_weight_to_int4pack', '_convolution',
|
|||
|
|
'_convolution_mode', '_copy_from', '_copy_from_and_resize', '_cslt_compress', '_cslt_sparse_mm',
|
|||
|
|
'_cslt_sparse_mm_search', '_ctc_loss', '_cudnn_ctc_loss', '_cudnn_init_dropout_state',
|
|||
|
|
'_cudnn_rnn', '_cudnn_rnn_flatten_weight', '_cufft_clear_plan_cache',
|
|||
|
|
'_cufft_get_plan_cache_max_size', '_cufft_get_plan_cache_size', '_cufft_set_plan_cache_max_size',
|
|||
|
|
'_cummax_helper', '_cummin_helper', '_debug_has_internal_overlap', '_dim_arange',
|
|||
|
|
'_dirichlet_grad', '_disable_functionalization', '_efficientzerotensor', '_embedding_bag',
|
|||
|
|
'_embedding_bag_forward_only', '_empty_affine_quantized', '_empty_per_channel_affine_quantized',
|
|||
|
|
'_enable_functionalization', '_euclidean_dist', '_fake_quantize_learnable_per_channel_affine',
|
|||
|
|
'_fake_quantize_learnable_per_tensor_affine',
|
|||
|
|
'_fake_quantize_per_tensor_affine_cachemask_tensor_qparams',
|
|||
|
|
'_fake_quantize_per_tensor_affine_cachemask_tensor_qparams', '_fft_c2c', '_fft_c2r', '_fft_r2c',
|
|||
|
|
'_fill_mem_eff_dropout_mask_', '_foobar', '_foreach_abs', '_foreach_abs_', '_foreach_acos',
|
|||
|
|
'_foreach_acos_', '_foreach_add', '_foreach_add_', '_foreach_addcdiv', '_foreach_addcdiv_',
|
|||
|
|
'_foreach_addcmul', '_foreach_addcmul_', '_foreach_asin', '_foreach_asin_', '_foreach_atan',
|
|||
|
|
'_foreach_atan_', '_foreach_ceil', '_foreach_ceil_', '_foreach_clamp_max', '_foreach_clamp_max_',
|
|||
|
|
'_foreach_clamp_min', '_foreach_clamp_min_', '_foreach_copy_', '_foreach_cos', '_foreach_cos_',
|
|||
|
|
'_foreach_cosh', '_foreach_cosh_', '_foreach_div', '_foreach_div_', '_foreach_erf',
|
|||
|
|
'_foreach_erf_', '_foreach_erfc', '_foreach_erfc_', '_foreach_exp', '_foreach_exp_',
|
|||
|
|
'_foreach_expm1', '_foreach_expm1_', '_foreach_floor', '_foreach_floor_', '_foreach_frac',
|
|||
|
|
'_foreach_frac_', '_foreach_lerp', '_foreach_lerp_', '_foreach_lgamma', '_foreach_lgamma_',
|
|||
|
|
'_foreach_log', '_foreach_log10', '_foreach_log10_', '_foreach_log1p', '_foreach_log1p_',
|
|||
|
|
'_foreach_log2', '_foreach_log2_', '_foreach_log_', '_foreach_maximum', '_foreach_maximum_',
|
|||
|
|
'_foreach_minimum', '_foreach_minimum_', '_foreach_mul', '_foreach_mul_', '_foreach_neg',
|
|||
|
|
'_foreach_neg_', '_foreach_norm', '_foreach_pow', '_foreach_pow_', '_foreach_reciprocal',
|
|||
|
|
'_foreach_reciprocal_', '_foreach_round', '_foreach_round_', '_foreach_sigmoid',
|
|||
|
|
'_foreach_sigmoid_', '_foreach_sign', '_foreach_sign_', '_foreach_sin', '_foreach_sin_',
|
|||
|
|
'_foreach_sinh', '_foreach_sinh_', '_foreach_sqrt', '_foreach_sqrt_', '_foreach_sub',
|
|||
|
|
'_foreach_sub_', '_foreach_tan', '_foreach_tan_', '_foreach_tanh', '_foreach_tanh_',
|
|||
|
|
'_foreach_trunc', '_foreach_trunc_', '_foreach_zero_', '_from_functional_tensor',
|
|||
|
|
'_functional_assert_async', '_functional_assert_scalar', '_functional_sym_constrain_range',
|
|||
|
|
'_functional_sym_constrain_range_for_size',
|
|||
|
|
'_functionalize_are_all_mutations_hidden_from_autograd',
|
|||
|
|
'_functionalize_are_all_mutations_under_no_grad_or_inference_mode', '_functionalize_commit_update',
|
|||
|
|
'_functionalize_mark_mutation_hidden_from_autograd', '_functionalize_replace',
|
|||
|
|
'_functionalize_sync', '_fused_adam_', '_fused_adamw_', '_fused_dropout',
|
|||
|
|
'_fused_moving_avg_obs_fq_helper', '_fused_moving_avg_obs_fq_helper', '_fused_sdp_choice',
|
|||
|
|
'_fused_sgd_', '_fw_primal_copy', '_grid_sampler_2d_cpu_fallback',
|
|||
|
|
'_has_compatible_shallow_copy_type', '_histogramdd_bin_edges', '_histogramdd_from_bin_cts',
|
|||
|
|
'_histogramdd_from_bin_tensors', '_index_put_impl_', '_indices_copy', '_int_mm', '_is_all_true',
|
|||
|
|
'_is_any_true', '_is_functional_tensor', '_is_zerotensor', '_lazy_clone', '_linalg_check_errors',
|
|||
|
|
'_linalg_det', '_linalg_det', '_linalg_eigh', '_linalg_eigh', '_linalg_slogdet', '_linalg_slogdet',
|
|||
|
|
'_linalg_solve_ex', '_linalg_solve_ex', '_linalg_svd', '_linalg_svd', '_log_softmax',
|
|||
|
|
'_log_softmax_backward_data', '_logcumsumexp', '_lstm_mps', '_lu_with_info', '_lu_with_info',
|
|||
|
|
'_make_dep_token', '_make_dual', '_make_dual_copy', '_make_per_channel_quantized_tensor',
|
|||
|
|
'_make_per_tensor_quantized_tensor', '_masked_scale', '_masked_softmax', '_mixed_dtypes_linear',
|
|||
|
|
'_mkldnn_reshape', '_mkldnn_transpose', '_mkldnn_transpose_', '_mps_convolution',
|
|||
|
|
'_mps_convolution_transpose', '_native_batch_norm_legit', '_native_batch_norm_legit_no_training',
|
|||
|
|
'_native_multi_head_attention', '_neg_view', '_neg_view_copy', '_nested_from_padded',
|
|||
|
|
'_nested_from_padded_and_nested_example', '_nested_get_jagged_dummy', '_nested_get_lengths',
|
|||
|
|
'_nested_get_offsets', '_nested_get_ragged_idx', '_nested_get_values', '_nested_get_values_copy',
|
|||
|
|
'_nested_tensor_from_mask', '_nested_tensor_from_mask_left_aligned',
|
|||
|
|
'_nested_tensor_from_tensor_list', '_nested_tensor_softmax_with_shape', '_nested_view_from_buffer',
|
|||
|
|
'_nested_view_from_buffer_copy', '_nested_view_from_jagged', '_nested_view_from_jagged_copy',
|
|||
|
|
'_nnpack_available', '_nnpack_spatial_convolution', '_pack_padded_sequence',
|
|||
|
|
'_pad_packed_sequence', '_pin_memory', '_prelu_kernel', '_print', '_propagate_xla_data',
|
|||
|
|
'_remove_batch_dim', '_reshape_alias_copy', '_reshape_from_tensor', '_resize_output_',
|
|||
|
|
'_rowwise_prune', '_sample_dirichlet', '_saturate_weight_to_fp16',
|
|||
|
|
'_scaled_dot_product_attention_math', '_scaled_dot_product_cudnn_attention',
|
|||
|
|
'_scaled_dot_product_cudnn_attention', '_scaled_dot_product_efficient_attention',
|
|||
|
|
'_scaled_dot_product_efficient_attention', '_scaled_dot_product_flash_attention',
|
|||
|
|
'_scaled_dot_product_flash_attention', '_scaled_dot_product_flash_attention_for_cpu',
|
|||
|
|
'_scaled_dot_product_flash_attention_for_cpu', '_scaled_mm', '_shape_as_tensor',
|
|||
|
|
'_sobol_engine_draw', '_sobol_engine_ff_', '_sobol_engine_initialize_state_',
|
|||
|
|
'_sobol_engine_scramble_', '_softmax', '_softmax_backward_data', '_sparse_broadcast_to',
|
|||
|
|
'_sparse_broadcast_to_copy', '_sparse_csr_prod', '_sparse_csr_sum',
|
|||
|
|
'_sparse_log_softmax_backward_data', '_sparse_semi_structured_linear',
|
|||
|
|
'_sparse_softmax_backward_data', '_sparse_sparse_matmul', '_sparse_sum', '_stack',
|
|||
|
|
'_standard_gamma', '_standard_gamma_grad', '_sync', '_test_autograd_multiple_dispatch',
|
|||
|
|
'_test_autograd_multiple_dispatch_view', '_test_autograd_multiple_dispatch_view_copy',
|
|||
|
|
'_test_check_tensor', '_test_functorch_fallback', '_test_parallel_materialize',
|
|||
|
|
'_test_serialization_subcmul', '_to_cpu', '_to_functional_tensor', '_to_sparse_semi_structured',
|
|||
|
|
'_transform_bias_rescale_qkv', '_transformer_encoder_layer_fwd', '_trilinear',
|
|||
|
|
'_triton_multi_head_attention', '_triton_scaled_dot_attention', '_unique', '_unique2',
|
|||
|
|
'_unpack_dual', '_unpack_dual', '_unsafe_index', '_unsafe_index_put', '_use_cudnn_ctc_loss',
|
|||
|
|
'_use_cudnn_rnn_flatten_weight', '_validate_compressed_sparse_indices',
|
|||
|
|
'_validate_sparse_bsc_tensor_args', '_validate_sparse_bsr_tensor_args',
|
|||
|
|
'_validate_sparse_compressed_tensor_args', '_validate_sparse_coo_tensor_args',
|
|||
|
|
'_validate_sparse_csc_tensor_args', '_validate_sparse_csr_tensor_args', '_values_copy',
|
|||
|
|
'_weight_int4pack_mm', '_weight_int8pack_mm', '_weight_norm', '_weight_norm_interface', 'abs',
|
|||
|
|
'abs_', 'absolute', 'acos', 'acos_', 'acosh', 'acosh_', 'adaptive_avg_pool1d',
|
|||
|
|
'adaptive_max_pool1d', 'add', 'addbmm', 'addcdiv', 'addcmul', 'addmm', 'addmv', 'addmv_', 'addr',
|
|||
|
|
'adjoint', 'affine_grid_generator', 'alias_copy', 'all', 'allclose', 'alpha_dropout',
|
|||
|
|
'alpha_dropout_', 'amax', 'amin', 'aminmax', 'aminmax', 'angle', 'any', 'arange', 'arccos',
|
|||
|
|
'arccos_', 'arccosh', 'arccosh_', 'arcsin', 'arcsin_', 'arcsinh', 'arcsinh_', 'arctan', 'arctan2',
|
|||
|
|
'arctan_', 'arctanh', 'arctanh_', 'argmax', 'argmin', 'argsort', 'argwhere', 'as_strided',
|
|||
|
|
'as_strided_', 'as_strided_copy', 'as_strided_scatter', 'as_tensor', 'asarray', 'asin', 'asin_',
|
|||
|
|
'asinh', 'asinh_', 'atan', 'atan2', 'atan_', 'atanh', 'atanh_', 'avg_pool1d', 'baddbmm',
|
|||
|
|
'bartlett_window', 'batch_norm', 'batch_norm_backward_elemt', 'batch_norm_backward_reduce',
|
|||
|
|
'batch_norm_elemt', 'batch_norm_gather_stats', 'batch_norm_gather_stats_with_counts',
|
|||
|
|
'batch_norm_stats', 'batch_norm_update_stats', 'bernoulli', 'bilinear',
|
|||
|
|
'binary_cross_entropy_with_logits', 'bincount', 'binomial', 'bitwise_and', 'bitwise_left_shift',
|
|||
|
|
'bitwise_not', 'bitwise_or', 'bitwise_right_shift', 'bitwise_xor', 'blackman_window', 'bmm',
|
|||
|
|
'broadcast_to', 'bucketize', 'can_cast', 'cat', 'ccol_indices_copy', 'ceil', 'ceil_', 'celu',
|
|||
|
|
'celu_', 'channel_shuffle', 'cholesky', 'cholesky_inverse', 'cholesky_solve',
|
|||
|
|
'choose_qparams_optimized', 'chunk', 'clamp', 'clamp_', 'clamp_max', 'clamp_max_', 'clamp_min',
|
|||
|
|
'clamp_min_', 'clip', 'clip_', 'clone', 'col_indices_copy', 'column_stack', 'combinations',
|
|||
|
|
'complex', 'concat', 'concatenate', 'conj', 'conj_physical', 'conj_physical_', 'constant_pad_nd',
|
|||
|
|
'conv1d', 'conv2d', 'conv3d', 'conv_tbc', 'conv_transpose1d', 'conv_transpose2d',
|
|||
|
|
'conv_transpose3d', 'convolution', 'copysign', 'corrcoef', 'cos', 'cos_', 'cosh', 'cosh_',
|
|||
|
|
'cosine_embedding_loss', 'cosine_similarity', 'count_nonzero', 'cov', 'cross', 'crow_indices_copy',
|
|||
|
|
'ctc_loss', 'cudnn_affine_grid_generator', 'cudnn_batch_norm', 'cudnn_convolution',
|
|||
|
|
'cudnn_convolution_add_relu', 'cudnn_convolution_relu', 'cudnn_convolution_transpose',
|
|||
|
|
'cudnn_grid_sampler', 'cudnn_is_acceptable', 'cummax', 'cummax', 'cummin', 'cummin', 'cumprod',
|
|||
|
|
'cumsum', 'cumulative_trapezoid', 'deg2rad', 'deg2rad_', 'dequantize', 'det', 'detach', 'detach_',
|
|||
|
|
'detach_copy', 'diag', 'diag_embed', 'diagflat', 'diagonal', 'diagonal_copy', 'diagonal_scatter',
|
|||
|
|
'diff', 'digamma', 'dist', 'div', 'divide', 'dot', 'dropout', 'dropout_', 'dsmm', 'dsplit',
|
|||
|
|
'dstack', 'embedding', 'embedding_bag', 'embedding_renorm_', 'empty', 'empty_like',
|
|||
|
|
'empty_permuted', 'empty_quantized', 'empty_strided', 'eq', 'equal', 'erf', 'erf_', 'erfc',
|
|||
|
|
'erfc_', 'erfinv', 'exp', 'exp2', 'exp2_', 'exp_', 'expand_copy', 'expm1', 'expm1_', 'eye',
|
|||
|
|
'fake_quantize_per_channel_affine', 'fake_quantize_per_tensor_affine', 'fbgemm_linear_fp16_weight',
|
|||
|
|
'fbgemm_linear_fp16_weight_fp32_activation', 'fbgemm_linear_int8_weight',
|
|||
|
|
'fbgemm_linear_int8_weight_fp32_activation', 'fbgemm_linear_quantize_weight',
|
|||
|
|
'fbgemm_pack_gemm_matrix_fp16', 'fbgemm_pack_quantized_matrix', 'feature_alpha_dropout',
|
|||
|
|
'feature_alpha_dropout_', 'feature_dropout', 'feature_dropout_', 'fill', 'fill_', 'fix', 'fix_',
|
|||
|
|
'flatten', 'flip', 'fliplr', 'flipud', 'float_power', 'floor', 'floor_', 'floor_divide', 'fmax',
|
|||
|
|
'fmin', 'fmod', 'frac', 'frac_', 'frexp', 'frexp', 'frobenius_norm', 'from_file', 'from_numpy',
|
|||
|
|
'frombuffer', 'full', 'full_like', 'fused_moving_avg_obs_fake_quant', 'gather', 'gcd', 'gcd_',
|
|||
|
|
'ge', 'geqrf', 'geqrf', 'ger', 'get_default_dtype', 'get_num_interop_threads', 'get_num_threads',
|
|||
|
|
'gradient', 'greater', 'greater_equal', 'grid_sampler', 'grid_sampler_2d', 'grid_sampler_3d',
|
|||
|
|
'group_norm', 'gru', 'gru_cell', 'gt', 'hamming_window', 'hann_window', 'hardshrink', 'heaviside',
|
|||
|
|
'hinge_embedding_loss', 'histc', 'histogram', 'histogram', 'histogramdd', 'histogramdd', 'hsmm',
|
|||
|
|
'hsplit', 'hspmm', 'hstack', 'hypot', 'i0', 'i0_', 'igamma', 'igammac', 'imag', 'index_add',
|
|||
|
|
'index_copy', 'index_fill', 'index_put', 'index_put_', 'index_reduce', 'index_select',
|
|||
|
|
'indices_copy', 'init_num_threads', 'inner', 'instance_norm', 'int_repr', 'inverse', 'is_complex',
|
|||
|
|
'is_conj', 'is_distributed', 'is_floating_point', 'is_grad_enabled', 'is_inference',
|
|||
|
|
'is_inference_mode_enabled', 'is_neg', 'is_nonzero', 'is_same_size', 'is_signed',
|
|||
|
|
'is_vulkan_available', 'isclose', 'isfinite', 'isin', 'isinf', 'isnan', 'isneginf', 'isposinf',
|
|||
|
|
'isreal', 'istft', 'kaiser_window', 'kl_div', 'kron', 'kthvalue', 'kthvalue', 'layer_norm', 'lcm',
|
|||
|
|
'lcm_', 'ldexp', 'ldexp_', 'le', 'lerp', 'less', 'less_equal', 'lgamma', 'linspace', 'log',
|
|||
|
|
'log10', 'log10_', 'log1p', 'log1p_', 'log2', 'log2_', 'log_', 'log_softmax', 'logaddexp',
|
|||
|
|
'logaddexp2', 'logcumsumexp', 'logdet', 'logical_and', 'logical_not', 'logical_or', 'logical_xor',
|
|||
|
|
'logit', 'logit_', 'logspace', 'logsumexp', 'lstm', 'lstm_cell', 'lt', 'lu_solve', 'lu_unpack',
|
|||
|
|
'lu_unpack', 'margin_ranking_loss', 'masked_fill', 'masked_scatter', 'masked_select', 'matmul',
|
|||
|
|
'matrix_exp', 'matrix_power', 'max', 'max', 'max_pool1d', 'max_pool1d_with_indices', 'max_pool2d',
|
|||
|
|
'max_pool3d', 'maximum', 'mean', 'median', 'median', 'min', 'min', 'minimum', 'miopen_batch_norm',
|
|||
|
|
'miopen_convolution', 'miopen_convolution_add_relu', 'miopen_convolution_relu',
|
|||
|
|
'miopen_convolution_transpose', 'miopen_depthwise_convolution', 'miopen_rnn',
|
|||
|
|
'mkldnn_adaptive_avg_pool2d', 'mkldnn_convolution', 'mkldnn_linear_backward_weights',
|
|||
|
|
'mkldnn_max_pool2d', 'mkldnn_max_pool3d', 'mkldnn_rnn_layer', 'mm', 'mode', 'mode', 'moveaxis',
|
|||
|
|
'movedim', 'msort', 'mul', 'multinomial', 'multiply', 'mv', 'mvlgamma', 'nan_to_num',
|
|||
|
|
'nan_to_num_', 'nanmean', 'nanmedian', 'nanmedian', 'nanquantile', 'nansum', 'narrow',
|
|||
|
|
'narrow_copy', 'native_batch_norm', 'native_channel_shuffle', 'native_dropout',
|
|||
|
|
'native_group_norm', 'native_layer_norm', 'native_norm', 'ne', 'neg', 'neg_', 'negative',
|
|||
|
|
'negative_', 'nextafter', 'nonzero', 'nonzero_static', 'norm_except_dim', 'normal', 'not_equal',
|
|||
|
|
'nuclear_norm', 'numel', 'ones', 'ones_like', 'orgqr', 'ormqr', 'outer', 'pairwise_distance',
|
|||
|
|
'pdist', 'permute', 'permute_copy', 'pinverse', 'pixel_shuffle', 'pixel_unshuffle', 'poisson',
|
|||
|
|
'poisson_nll_loss', 'polar', 'polygamma', 'positive', 'pow', 'prelu', 'prod', 'promote_types',
|
|||
|
|
'put', 'q_per_channel_axis', 'q_per_channel_scales', 'q_per_channel_zero_points', 'q_scale',
|
|||
|
|
'q_zero_point', 'qr', 'qr', 'quantile', 'quantize_per_channel', 'quantize_per_tensor',
|
|||
|
|
'quantize_per_tensor_dynamic', 'quantized_batch_norm', 'quantized_gru_cell', 'quantized_lstm_cell',
|
|||
|
|
'quantized_max_pool1d', 'quantized_max_pool2d', 'quantized_max_pool3d', 'quantized_rnn_relu_cell',
|
|||
|
|
'quantized_rnn_tanh_cell', 'rad2deg', 'rad2deg_', 'rand', 'rand_like', 'randint', 'randint_like',
|
|||
|
|
'randn', 'randn_like', 'randperm', 'range', 'ravel', 'real', 'reciprocal', 'reciprocal_', 'relu',
|
|||
|
|
'relu_', 'remainder', 'renorm', 'repeat_interleave', 'reshape', 'resize_as_', 'resize_as_sparse_',
|
|||
|
|
'resolve_conj', 'resolve_neg', 'result_type', 'rnn_relu', 'rnn_relu_cell', 'rnn_tanh',
|
|||
|
|
'rnn_tanh_cell', 'roll', 'rot90', 'round', 'round_', 'row_indices_copy', 'row_stack', 'rrelu',
|
|||
|
|
'rrelu_', 'rsqrt', 'rsqrt_', 'rsub', 'saddmm', 'scalar_tensor', 'scatter', 'scatter_add',
|
|||
|
|
'scatter_reduce', 'searchsorted', 'segment_reduce', 'select', 'select_copy', 'select_scatter',
|
|||
|
|
'selu', 'selu_', 'set_flush_denormal', 'set_num_interop_threads', 'set_num_threads', 'sgn',
|
|||
|
|
'sigmoid', 'sigmoid_', 'sign', 'signbit', 'sin', 'sin_', 'sinc', 'sinc_', 'sinh', 'sinh_',
|
|||
|
|
'slice_copy', 'slice_inverse', 'slice_scatter', 'slogdet', 'slogdet', 'smm', 'softmax', 'sort',
|
|||
|
|
'sort', 'sparse_bsc_tensor', 'sparse_bsr_tensor', 'sparse_compressed_tensor', 'sparse_coo_tensor',
|
|||
|
|
'sparse_csc_tensor', 'sparse_csr_tensor', 'split_copy', 'split_with_sizes',
|
|||
|
|
'split_with_sizes_copy', 'spmm', 'sqrt', 'sqrt_', 'square', 'square_', 'squeeze', 'squeeze_copy',
|
|||
|
|
'sspaddmm', 'stack', 'std', 'std_mean', 'sub', 'subtract', 'sum', 'svd', 'svd', 'swapaxes',
|
|||
|
|
'swapdims', 'sym_constrain_range', 'sym_constrain_range_for_size', 't', 't_copy', 'take',
|
|||
|
|
'take_along_dim', 'tan', 'tan_', 'tanh', 'tanh_', 'tensor', 'tensor_split', 'threshold',
|
|||
|
|
'threshold_', 'tile', 'topk', 'topk', 'trace', 'transpose', 'transpose_copy', 'trapezoid', 'trapz',
|
|||
|
|
'triangular_solve', 'triangular_solve', 'tril', 'tril_indices', 'triplet_margin_loss', 'triu',
|
|||
|
|
'triu_indices', 'true_divide', 'trunc', 'trunc_', 'unbind', 'unbind_copy', 'unflatten',
|
|||
|
|
'unfold_copy', 'unique_dim', 'unsafe_chunk', 'unsafe_split', 'unsafe_split_with_sizes',
|
|||
|
|
'unsqueeze', 'unsqueeze_copy', 'values_copy', 'vander', 'var', 'var_mean', 'vdot',
|
|||
|
|
'view_as_complex', 'view_as_complex_copy', 'view_as_real', 'view_as_real_copy', 'view_copy',
|
|||
|
|
'vsplit', 'vstack', 'where', 'xlogy', 'xlogy_', 'zero_', 'zeros', 'zeros_like']
|