pub struct Tensor { /* private fields */ }
Expand description
A tensor object.
Implementations
sourceimpl Tensor
impl Tensor
sourcepub unsafe fn from_ptr(c_tensor: *mut C_tensor) -> Self
pub unsafe fn from_ptr(c_tensor: *mut C_tensor) -> Self
Creates a new tensor from the pointer to an existing C++ tensor.
Safety
The caller must ensures that the pointer outlives the Rust object.
sourcepub unsafe fn clone_from_ptr(c_tensor: *mut C_tensor) -> Self
pub unsafe fn clone_from_ptr(c_tensor: *mut C_tensor) -> Self
Creates a new tensor from the pointer to an existing C++ tensor.
Safety
A shallow copy of the pointer is made so there is no need for this pointer to remain valid for the whole lifetime of the Rust object.
sourcepub fn as_ptr(&self) -> *const C_tensor
pub fn as_ptr(&self) -> *const C_tensor
Returns a pointer to the underlying C++ tensor.
The caller must ensures that the Rust tensor object outlives this pointer.
sourcepub fn as_mut_ptr(&mut self) -> *mut C_tensor
pub fn as_mut_ptr(&mut self) -> *mut C_tensor
Returns a mutable pointer to the underlying C++ tensor.
The caller must ensures that the Rust tensor object outlives this pointer.
sourcepub fn size1(&self) -> Result<i64, TchError>
pub fn size1(&self) -> Result<i64, TchError>
Returns the tensor size for single dimension tensors.
sourcepub fn size2(&self) -> Result<(i64, i64), TchError>
pub fn size2(&self) -> Result<(i64, i64), TchError>
Returns the tensor sizes for two dimension tensors.
sourcepub fn size3(&self) -> Result<(i64, i64, i64), TchError>
pub fn size3(&self) -> Result<(i64, i64, i64), TchError>
Returns the tensor sizes for three dimension tensors.
sourcepub fn size4(&self) -> Result<(i64, i64, i64, i64), TchError>
pub fn size4(&self) -> Result<(i64, i64, i64, i64), TchError>
Returns the tensor sizes for four dimension tensors.
sourcepub fn size5(&self) -> Result<(i64, i64, i64, i64, i64), TchError>
pub fn size5(&self) -> Result<(i64, i64, i64, i64, i64), TchError>
Returns the tensor sizes for five dimension tensors.
sourcepub fn size6(&self) -> Result<(i64, i64, i64, i64, i64, i64), TchError>
pub fn size6(&self) -> Result<(i64, i64, i64, i64, i64, i64), TchError>
Returns the tensor sizes for six dimension tensors.
sourcepub fn stride1(&self) -> Result<i64, TchError>
pub fn stride1(&self) -> Result<i64, TchError>
Returns the tensor strides for single dimension tensors.
sourcepub fn stride2(&self) -> Result<(i64, i64), TchError>
pub fn stride2(&self) -> Result<(i64, i64), TchError>
Returns the tensor strides for two dimension tensors.
sourcepub fn stride3(&self) -> Result<(i64, i64, i64), TchError>
pub fn stride3(&self) -> Result<(i64, i64, i64), TchError>
Returns the tensor strides for three dimension tensors.
sourcepub fn stride4(&self) -> Result<(i64, i64, i64, i64), TchError>
pub fn stride4(&self) -> Result<(i64, i64, i64, i64), TchError>
Returns the tensor strides for four dimension tensors.
sourcepub fn stride5(&self) -> Result<(i64, i64, i64, i64, i64), TchError>
pub fn stride5(&self) -> Result<(i64, i64, i64, i64, i64), TchError>
Returns the tensor strides for five dimension tensors.
sourcepub fn stride6(&self) -> Result<(i64, i64, i64, i64, i64, i64), TchError>
pub fn stride6(&self) -> Result<(i64, i64, i64, i64, i64, i64), TchError>
Returns the tensor strides for six dimension tensors.
sourcepub fn f_kind(&self) -> Result<Kind, TchError>
pub fn f_kind(&self) -> Result<Kind, TchError>
Returns the kind of elements stored in the input tensor. Returns an error on undefined tensors and unsupported data types.
sourcepub fn kind(&self) -> Kind
pub fn kind(&self) -> Kind
Returns the kind of elements stored in the input tensor. Panics an error on undefined tensors and unsupported data types.
sourcepub fn print(&self)
pub fn print(&self)
Prints the input tensor.
Caution: this uses the C++ printer which prints the whole tensor even if it is very large.
sourcepub fn f_double_value(&self, idx: &[i64]) -> Result<f64, TchError>
pub fn f_double_value(&self, idx: &[i64]) -> Result<f64, TchError>
Returns a double value on tensors holding a single element. An error is returned otherwise.
sourcepub fn f_int64_value(&self, idx: &[i64]) -> Result<i64, TchError>
pub fn f_int64_value(&self, idx: &[i64]) -> Result<i64, TchError>
Returns an int value on tensors holding a single element. An error is returned otherwise.
sourcepub fn double_value(&self, idx: &[i64]) -> f64
pub fn double_value(&self, idx: &[i64]) -> f64
Returns a double value on tensors holding a single element. Panics otherwise.
sourcepub fn int64_value(&self, idx: &[i64]) -> i64
pub fn int64_value(&self, idx: &[i64]) -> i64
Returns an int value on tensors holding a single element. Panics otherwise.
sourcepub fn requires_grad(&self) -> bool
pub fn requires_grad(&self) -> bool
Returns true if gradient are currently tracked for this tensor.
sourcepub fn is_mkldnn(&self) -> bool
pub fn is_mkldnn(&self) -> bool
Returns true if the tensor is compatible with MKL-DNN (oneDNN).
sourcepub fn f_backward(&self) -> Result<(), TchError>
pub fn f_backward(&self) -> Result<(), TchError>
Runs the backward pass, populating the gradient tensors for tensors which gradients are tracked.
Gradients tracking can be turned on via set_requires_grad
.
sourcepub fn backward(&self)
pub fn backward(&self)
Runs the backward pass, populating the gradient tensors for tensors which gradients are tracked.
Gradients tracking can be turned on via set_requires_grad
.
Panics if the C++ api returns an exception.
pub fn f_run_backward<T1, T2>(
tensors: &[T1],
inputs: &[T2],
keep_graph: bool,
create_graph: bool
) -> Result<Vec<Tensor>, TchError> where
T1: Borrow<Tensor>,
T2: Borrow<Tensor>,
pub fn run_backward<T1, T2>(
tensors: &[T1],
inputs: &[T2],
keep_graph: bool,
create_graph: bool
) -> Vec<Tensor> where
T1: Borrow<Tensor>,
T2: Borrow<Tensor>,
sourcepub fn f_copy_data_u8(
&self,
dst: &mut [u8],
numel: usize
) -> Result<(), TchError>
pub fn f_copy_data_u8(
&self,
dst: &mut [u8],
numel: usize
) -> Result<(), TchError>
Copies numel
elements from self
to dst
.
sourcepub fn f_internal_amp_non_finite_check_and_unscale(
&mut self,
found_inf: &mut Tensor,
inv_scale: &Tensor
) -> Result<(), TchError>
pub fn f_internal_amp_non_finite_check_and_unscale(
&mut self,
found_inf: &mut Tensor,
inv_scale: &Tensor
) -> Result<(), TchError>
Unscale tensor while checking for infinities.
found_inf
is a singleton tensor that is used to record the
presence of infinite values. inv_scale
is a scalar containing
the inverse scaling factor. This method is only available
for CUDA tensors.
sourcepub fn internal_amp_non_finite_check_and_unscale(
&mut self,
found_inf: &mut Tensor,
inv_scale: &Tensor
)
pub fn internal_amp_non_finite_check_and_unscale(
&mut self,
found_inf: &mut Tensor,
inv_scale: &Tensor
)
Unscale tensor while checking for infinities.
found_inf
is a singleton tensor that is used to record the
presence of infinite values. inv_scale
is a scalar containing
the inverse scaling factor. This method is only available
for CUDA tensors.
sourcepub fn copy_data_u8(&self, dst: &mut [u8], numel: usize)
pub fn copy_data_u8(&self, dst: &mut [u8], numel: usize)
Copies numel
elements from self
to dst
.
sourcepub fn f_copy_data<T: Element>(
&self,
dst: &mut [T],
numel: usize
) -> Result<(), TchError>
pub fn f_copy_data<T: Element>(
&self,
dst: &mut [T],
numel: usize
) -> Result<(), TchError>
Copies numel
elements from self
to dst
.
sourcepub fn copy_data<T: Element>(&self, dst: &mut [T], numel: usize)
pub fn copy_data<T: Element>(&self, dst: &mut [T], numel: usize)
Copies numel
elements from self
to dst
.
sourcepub fn f_of_slice<T: Element>(data: &[T]) -> Result<Tensor, TchError>
pub fn f_of_slice<T: Element>(data: &[T]) -> Result<Tensor, TchError>
Converts a slice to a tensor.
sourcepub fn f_of_data_size(
data: &[u8],
size: &[i64],
kind: Kind
) -> Result<Tensor, TchError>
pub fn f_of_data_size(
data: &[u8],
size: &[i64],
kind: Kind
) -> Result<Tensor, TchError>
Converts some byte data to a tensor with some specified kind and shape.
sourcepub unsafe fn f_of_blob(
data: *const u8,
size: &[i64],
strides: &[i64],
kind: Kind,
device: Device
) -> Result<Tensor, TchError>
pub unsafe fn f_of_blob(
data: *const u8,
size: &[i64],
strides: &[i64],
kind: Kind,
device: Device
) -> Result<Tensor, TchError>
Creates a tensor from data that is assumed to be initialized. Resize operations are now allowed on this tensor without copying the data first.
Safety
This will panic if data
points to invalid data.
sourcepub unsafe fn of_blob(
data: *const u8,
size: &[i64],
strides: &[i64],
kind: Kind,
device: Device
) -> Tensor
pub unsafe fn of_blob(
data: *const u8,
size: &[i64],
strides: &[i64],
kind: Kind,
device: Device
) -> Tensor
Creates a tensor from data that is assumed to be initialized. Resize operations are now allowed on this tensor without copying the data first.
Safety
This will panic if data
points to invalid data.
sourcepub fn of_data_size(data: &[u8], size: &[i64], kind: Kind) -> Tensor
pub fn of_data_size(data: &[u8], size: &[i64], kind: Kind) -> Tensor
Converts some byte data to a tensor with some specified kind and shape.
sourcepub fn shallow_clone(&self) -> Tensor
pub fn shallow_clone(&self) -> Tensor
Returns a new tensor that share storage with the input tensor.
sourcepub fn f_get(&self, index: i64) -> Result<Tensor, TchError>
pub fn f_get(&self, index: i64) -> Result<Tensor, TchError>
Gets the sub-tensor at the given index.
sourcepub fn f_copy_(&mut self, src: &Tensor) -> Result<(), TchError>
pub fn f_copy_(&mut self, src: &Tensor) -> Result<(), TchError>
Copies values from the argument tensor to the input tensor.
sourcepub fn copy_(&mut self, src: &Tensor)
pub fn copy_(&mut self, src: &Tensor)
Copies values from the argument tensor to the input tensor.
sourcepub fn load<T: AsRef<Path>>(path: T) -> Result<Tensor, TchError>
pub fn load<T: AsRef<Path>>(path: T) -> Result<Tensor, TchError>
Loads a tensor from a file.
The file format is the same as the one used by the PyTorch C++ API.
sourcepub fn load_from_stream<T: Read + Seek>(stream: T) -> Result<Tensor, TchError>
pub fn load_from_stream<T: Read + Seek>(stream: T) -> Result<Tensor, TchError>
Loads a tensor from a stream.
The file format is the same as the one used by the PyTorch C++ API.
sourcepub fn save<T: AsRef<Path>>(&self, path: T) -> Result<(), TchError>
pub fn save<T: AsRef<Path>>(&self, path: T) -> Result<(), TchError>
Saves a tensor to a file.
The file format is the same as the one used by the PyTorch C++ API.
sourcepub fn save_to_stream<W: Write>(&self, stream: W) -> Result<(), TchError>
pub fn save_to_stream<W: Write>(&self, stream: W) -> Result<(), TchError>
Saves a tensor to a stream.
The file format is the same as the one used by the PyTorch C++ API.
sourcepub fn save_multi<S: AsRef<str>, T: AsRef<Tensor>, P: AsRef<Path>>(
named_tensors: &[(S, T)],
path: P
) -> Result<(), TchError>
pub fn save_multi<S: AsRef<str>, T: AsRef<Tensor>, P: AsRef<Path>>(
named_tensors: &[(S, T)],
path: P
) -> Result<(), TchError>
Saves some named tensors to a file
The file format is the same as the one used by the PyTorch C++ API.
sourcepub fn save_multi_to_stream<S: AsRef<str>, T: AsRef<Tensor>, W: Write>(
named_tensors: &[(S, T)],
stream: W
) -> Result<(), TchError>
pub fn save_multi_to_stream<S: AsRef<str>, T: AsRef<Tensor>, W: Write>(
named_tensors: &[(S, T)],
stream: W
) -> Result<(), TchError>
Saves some named tensors to a stream
The file format is the same as the one used by the PyTorch C++ API.
sourcepub fn load_multi<T: AsRef<Path>>(
path: T
) -> Result<Vec<(String, Tensor)>, TchError>
pub fn load_multi<T: AsRef<Path>>(
path: T
) -> Result<Vec<(String, Tensor)>, TchError>
Loads some named tensors from a file
The file format is the same as the one used by the PyTorch C++ API.
sourcepub fn load_multi_with_device<T: AsRef<Path>>(
path: T,
device: Device
) -> Result<Vec<(String, Tensor)>, TchError>
pub fn load_multi_with_device<T: AsRef<Path>>(
path: T,
device: Device
) -> Result<Vec<(String, Tensor)>, TchError>
Loads some named tensors from a file to a given device
The file format is the same as the one used by the PyTorch C++ API.
sourcepub fn load_multi_from_stream<T: Read + Seek>(
stream: T
) -> Result<Vec<(String, Tensor)>, TchError>
pub fn load_multi_from_stream<T: Read + Seek>(
stream: T
) -> Result<Vec<(String, Tensor)>, TchError>
Loads some named tensors from a stream
The file format is the same as the one used by the PyTorch C++ API.
sourceimpl Tensor
impl Tensor
pub fn f_internal_and_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_internal_and_tensor_(
&mut self,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_iand_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_internal_iand_tensor_(
&mut self,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_ilshift_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_internal_ilshift_tensor_(
&mut self,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_ior_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_internal_ior_tensor_(
&mut self,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_irshift_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_internal_irshift_tensor_(
&mut self,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_ixor_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_internal_ixor_tensor_(
&mut self,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_lshift_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_internal_lshift_tensor_(
&mut self,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_or_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_internal_or_tensor_(
&mut self,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_rshift_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_internal_rshift_tensor_(
&mut self,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_xor_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_internal_xor_tensor_(
&mut self,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_adaptive_avg_pool2d(
&self,
output_size: &[i64]
) -> Result<Tensor, TchError>
pub fn f_internal_adaptive_avg_pool2d_backward(
&self,
grad_output: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_adaptive_avg_pool3d(
&self,
output_size: &[i64]
) -> Result<Tensor, TchError>
pub fn f_internal_adaptive_avg_pool3d_backward(
&self,
grad_output: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_add_batch_dim(
&self,
batch_dim: i64,
level: i64
) -> Result<Tensor, TchError>
pub fn f_internal_add_relu(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_internal_add_relu_(
&mut self,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_add_relu_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_add_relu_scalar<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_internal_add_relu_scalar_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_internal_aminmax(&self) -> Result<(Tensor, Tensor), TchError>
pub fn f_internal_aminmax_dim(
&self,
dim: i64,
keepdim: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_internal_amp_update_scale_(
&mut self,
growth_tracker: &Tensor,
found_inf: &Tensor,
scale_growth_factor: f64,
scale_backoff_factor: f64,
growth_interval: i64
) -> Result<Tensor, TchError>
pub fn f_internal_autocast_to_full_precision(
&self,
cuda_enabled: bool,
cpu_enabled: bool
) -> Result<Tensor, TchError>
pub fn f_internal_autocast_to_reduced_precision(
&self,
cuda_enabled: bool,
cpu_enabled: bool,
cuda_dtype: Kind,
cpu_dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_internal_cast_byte(
&self,
non_blocking: bool
) -> Result<Tensor, TchError>
pub fn f_internal_cast_char(
&self,
non_blocking: bool
) -> Result<Tensor, TchError>
pub fn f_internal_cast_double(
&self,
non_blocking: bool
) -> Result<Tensor, TchError>
pub fn f_internal_cast_float(
&self,
non_blocking: bool
) -> Result<Tensor, TchError>
pub fn f_internal_cast_half(
&self,
non_blocking: bool
) -> Result<Tensor, TchError>
pub fn f_internal_cast_int(
&self,
non_blocking: bool
) -> Result<Tensor, TchError>
pub fn f_internal_cast_long(
&self,
non_blocking: bool
) -> Result<Tensor, TchError>
pub fn f_internal_cast_short(
&self,
non_blocking: bool
) -> Result<Tensor, TchError>
pub fn f_internal_cat<T: Borrow<Tensor>>(
tensors: &[T],
dim: i64
) -> Result<Tensor, TchError>
pub fn f_internal_cat_out<T: Borrow<Tensor>>(
out: &Tensor,
tensors: &[T],
dim: i64
) -> Result<Tensor, TchError>
pub fn f_internal_cdist_backward(
grad: &Tensor,
x1: &Tensor,
x2: &Tensor,
p: f64,
cdist: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_cholesky_solve_helper(
&self,
a: &Tensor,
upper: bool
) -> Result<Tensor, TchError>
pub fn f_internal_coalesce(&self) -> Result<Tensor, TchError>
pub fn f_internal_coalesced_(
&mut self,
coalesced: bool
) -> Result<Tensor, TchError>
pub fn f_internal_compute_linear_combination(
&self,
coefficients: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_compute_linear_combination_out(
&self,
out: &Tensor,
coefficients: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_conj(&self) -> Result<Tensor, TchError>
pub fn f_internal_conj_physical(&self) -> Result<Tensor, TchError>
pub fn f_internal_conv_depthwise2d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
kernel_size: &[i64],
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64]
) -> Result<Tensor, TchError>
pub fn f_internal_conv_depthwise2d_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
weight: &Tensor,
kernel_size: &[i64],
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64]
) -> Result<Tensor, TchError>
pub fn f_internal_convert_indices_from_coo_to_csr(
&self,
size: i64,
out_int32: bool
) -> Result<Tensor, TchError>
pub fn f_internal_convert_indices_from_coo_to_csr_out(
&self,
out: &Tensor,
size: i64,
out_int32: bool
) -> Result<Tensor, TchError>
pub fn f_internal_convert_indices_from_csr_to_coo(
crow_indices: &Tensor,
col_indices: &Tensor,
out_int32: bool,
transpose: bool
) -> Result<Tensor, TchError>
pub fn f_internal_convert_indices_from_csr_to_coo_out(
out: &Tensor,
crow_indices: &Tensor,
col_indices: &Tensor,
out_int32: bool,
transpose: bool
) -> Result<Tensor, TchError>
pub fn f_internal_convolution<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
transposed: bool,
output_padding: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool,
cudnn_enabled: bool,
allow_tf32: bool
) -> Result<Tensor, TchError>
pub fn f_internal_convolution_deprecated<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
transposed: bool,
output_padding: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool,
cudnn_enabled: bool
) -> Result<Tensor, TchError>
pub fn f_internal_convolution_mode<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &str,
dilation: &[i64],
groups: i64
) -> Result<Tensor, TchError>
pub fn f_internal_copy_from(
&self,
dst: &Tensor,
non_blocking: bool
) -> Result<Tensor, TchError>
pub fn f_internal_copy_from_and_resize(
&self,
dst: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_ctc_loss(
log_probs: &Tensor,
targets: &Tensor,
input_lengths: &[i64],
target_lengths: &[i64],
blank: i64,
zero_infinity: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_internal_ctc_loss_backward(
grad: &Tensor,
log_probs: &Tensor,
targets: &Tensor,
input_lengths: &[i64],
target_lengths: &[i64],
neg_log_likelihood: &Tensor,
log_alpha: &Tensor,
blank: i64,
zero_infinity: bool
) -> Result<Tensor, TchError>
pub fn f_internal_cudnn_ctc_loss(
log_probs: &Tensor,
targets: &Tensor,
input_lengths: &[i64],
target_lengths: &[i64],
blank: i64,
deterministic: bool,
zero_infinity: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_internal_cudnn_init_dropout_state(
dropout: f64,
train: bool,
dropout_seed: i64,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_internal_cudnn_rnn<T: Borrow<Tensor>>(
&self,
weight: &[T],
weight_stride0: i64,
weight_buf: Option<T>,
hx: &Tensor,
cx: Option<T>,
mode: i64,
hidden_size: i64,
proj_size: i64,
num_layers: i64,
batch_first: bool,
dropout: f64,
train: bool,
bidirectional: bool,
batch_sizes: &[i64],
dropout_state: Option<T>
) -> Result<(Tensor, Tensor, Tensor, Tensor, Tensor), TchError>
pub fn f_internal_cudnn_rnn_flatten_weight<T: Borrow<Tensor>>(
weight_arr: &[T],
weight_stride0: i64,
input_size: i64,
mode: i64,
hidden_size: i64,
proj_size: i64,
num_layers: i64,
batch_first: bool,
bidirectional: bool
) -> Result<Tensor, TchError>
pub fn f_internal_cufft_get_plan_cache_max_size(
device_index: i64
) -> Result<i64, TchError>
pub fn f_internal_cufft_get_plan_cache_size(
device_index: i64
) -> Result<i64, TchError>
pub fn f_internal_debug_has_internal_overlap(&self) -> Result<i64, TchError>
pub fn f_internal_det_lu_based_helper(
&self
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_internal_det_lu_based_helper_backward_helper(
&self,
det_grad: &Tensor,
det: &Tensor,
lu: &Tensor,
pivs: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_dim_arange(
like: &Tensor,
dim: i64
) -> Result<Tensor, TchError>
pub fn f_internal_dimi(&self) -> Result<i64, TchError>
pub fn f_internal_dimv(&self) -> Result<i64, TchError>
pub fn f_internal_dirichlet_grad(
x: &Tensor,
alpha: &Tensor,
total: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_efficientzerotensor(
size: &[i64],
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_internal_embedding_bag<T: Borrow<Tensor>>(
weight: &Tensor,
indices: &Tensor,
offsets: &Tensor,
scale_grad_by_freq: bool,
mode: i64,
sparse: bool,
per_sample_weights: Option<T>,
include_last_offset: bool,
padding_idx: i64
) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>
pub fn f_internal_embedding_bag_backward<T: Borrow<Tensor>>(
grad: &Tensor,
indices: &Tensor,
offsets: &Tensor,
offset2bag: &Tensor,
bag_size: &Tensor,
maximum_indices: &Tensor,
num_weights: i64,
scale_grad_by_freq: bool,
mode: i64,
sparse: bool,
per_sample_weights: Option<T>,
padding_idx: i64
) -> Result<Tensor, TchError>
pub fn f_internal_embedding_bag_dense_backward<T: Borrow<Tensor>>(
grad: &Tensor,
indices: &Tensor,
offset2bag: &Tensor,
bag_size: &Tensor,
maximum_indices: &Tensor,
num_weights: i64,
scale_grad_by_freq: bool,
mode: i64,
per_sample_weights: Option<T>,
padding_idx: i64
) -> Result<Tensor, TchError>
pub fn f_internal_embedding_bag_forward_only<T: Borrow<Tensor>>(
weight: &Tensor,
indices: &Tensor,
offsets: &Tensor,
scale_grad_by_freq: bool,
mode: i64,
sparse: bool,
per_sample_weights: Option<T>,
include_last_offset: bool,
padding_idx: i64
) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>
pub fn f_internal_embedding_bag_per_sample_weights_backward(
grad: &Tensor,
weight: &Tensor,
indices: &Tensor,
offsets: &Tensor,
offset2bag: &Tensor,
mode: i64,
padding_idx: i64
) -> Result<Tensor, TchError>
pub fn f_internal_embedding_bag_sparse_backward<T: Borrow<Tensor>>(
grad: &Tensor,
indices: &Tensor,
offsets: &Tensor,
offset2bag: &Tensor,
bag_size: &Tensor,
num_weights: i64,
scale_grad_by_freq: bool,
mode: i64,
per_sample_weights: Option<T>,
padding_idx: i64
) -> Result<Tensor, TchError>
pub fn f_internal_empty_affine_quantized(
size: &[i64],
options: (Kind, Device),
scale: f64,
zero_point: i64
) -> Result<Tensor, TchError>
pub fn f_internal_empty_per_channel_affine_quantized(
size: &[i64],
scales: &Tensor,
zero_points: &Tensor,
axis: i64,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_internal_euclidean_dist(
x1: &Tensor,
x2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_fake_quantize_learnable_per_channel_affine(
&self,
scale: &Tensor,
zero_point: &Tensor,
axis: i64,
quant_min: i64,
quant_max: i64,
grad_factor: f64
) -> Result<Tensor, TchError>
pub fn f_internal_fake_quantize_learnable_per_channel_affine_backward(
&self,
grad: &Tensor,
scale: &Tensor,
zero_point: &Tensor,
axis: i64,
quant_min: i64,
quant_max: i64,
grad_factor: f64
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_internal_fake_quantize_learnable_per_tensor_affine(
&self,
scale: &Tensor,
zero_point: &Tensor,
quant_min: i64,
quant_max: i64,
grad_factor: f64
) -> Result<Tensor, TchError>
pub fn f_internal_fake_quantize_learnable_per_tensor_affine_backward(
&self,
grad: &Tensor,
scale: &Tensor,
zero_point: &Tensor,
quant_min: i64,
quant_max: i64,
grad_factor: f64
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_internal_fake_quantize_per_tensor_affine_cachemask_tensor_qparams(
&self,
scale: &Tensor,
zero_point: &Tensor,
fake_quant_enabled: &Tensor,
quant_min: i64,
quant_max: i64
) -> Result<(Tensor, Tensor), TchError>
pub fn f_internal_fft_c2c(
&self,
dim: &[i64],
normalization: i64,
forward: bool
) -> Result<Tensor, TchError>
pub fn f_internal_fft_c2c_out(
&self,
out: &Tensor,
dim: &[i64],
normalization: i64,
forward: bool
) -> Result<Tensor, TchError>
pub fn f_internal_fft_c2r(
&self,
dim: &[i64],
normalization: i64,
last_dim_size: i64
) -> Result<Tensor, TchError>
pub fn f_internal_fft_c2r_out(
&self,
out: &Tensor,
dim: &[i64],
normalization: i64,
last_dim_size: i64
) -> Result<Tensor, TchError>
pub fn f_internal_fft_r2c(
&self,
dim: &[i64],
normalization: i64,
onesided: bool
) -> Result<Tensor, TchError>
pub fn f_internal_fft_r2c_out(
&self,
out: &Tensor,
dim: &[i64],
normalization: i64,
onesided: bool
) -> Result<Tensor, TchError>
pub fn f_internal_fused_dropout(
&self,
p: f64
) -> Result<(Tensor, Tensor), TchError>
pub fn f_internal_fused_moving_avg_obs_fq_helper(
&self,
observer_on: &Tensor,
fake_quant_on: &Tensor,
running_min: &Tensor,
running_max: &Tensor,
scale: &Tensor,
zero_point: &Tensor,
averaging_const: f64,
quant_min: i64,
quant_max: i64,
ch_axis: i64,
per_row_fake_quant: bool,
symmetric_quant: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_internal_fw_primal(&self, level: i64) -> Result<Tensor, TchError>
pub fn f_internal_gather_sparse_backward(
&self,
dim: i64,
index: &Tensor,
grad: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_grid_sampler_2d_cpu_fallback(
&self,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64,
align_corners: bool
) -> Result<Tensor, TchError>
pub fn f_internal_grid_sampler_2d_cpu_fallback_backward(
&self,
grad_output: &Tensor,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64,
align_corners: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_internal_has_compatible_shallow_copy_type(
&self,
from: &Tensor
) -> Result<bool, TchError>
pub fn f_internal_has_same_storage_numel(
&self,
other: &Tensor
) -> Result<bool, TchError>
pub fn f_internal_histogramdd_bin_edges<T: Borrow<Tensor>>(
&self,
bins: &[i64],
range: &[f64],
weight: Option<T>,
density: bool
) -> Result<Vec<Tensor>, TchError>
pub fn f_internal_histogramdd_from_bin_cts<T: Borrow<Tensor>>(
&self,
bins: &[i64],
range: &[f64],
weight: Option<T>,
density: bool
) -> Result<Tensor, TchError>
pub fn f_internal_histogramdd_from_bin_tensors<T: Borrow<Tensor>>(
&self,
bins: &[T],
weight: Option<T>,
density: bool
) -> Result<Tensor, TchError>
pub fn f_internal_index_copy_(
&mut self,
dim: i64,
index: &Tensor,
source: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_index_put_impl_<T: Borrow<Tensor>>(
&mut self,
indices: &[Option<T>],
values: &Tensor,
accumulate: bool,
unsafe_: bool
) -> Result<Tensor, TchError>
pub fn f_internal_indices(&self) -> Result<Tensor, TchError>
pub fn f_internal_is_zerotensor(&self) -> Result<bool, TchError>
pub fn f_internal_linalg_check_errors(
info: &Tensor,
api_name: &str,
is_matrix: bool
) -> Result<(), TchError>
pub fn f_internal_linalg_inv_out_helper_(
&mut self,
infos_lu: &Tensor,
infos_getri: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_linalg_qr_helper(
&self,
mode: &str
) -> Result<(Tensor, Tensor), TchError>
pub fn f_internal_linalg_svd(
a: &Tensor,
full_matrices: bool,
compute_uv: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_internal_linalg_svd_u(
u: &Tensor,
s: &Tensor,
vh: &Tensor,
a: &Tensor,
full_matrices: bool,
compute_uv: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_internal_log_softmax(
&self,
dim: i64,
half_to_float: bool
) -> Result<Tensor, TchError>
pub fn f_internal_log_softmax_backward_data(
grad_output: &Tensor,
output: &Tensor,
dim: i64,
input_dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_internal_log_softmax_backward_data_out(
out: &Tensor,
grad_output: &Tensor,
output: &Tensor,
dim: i64,
input_dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_internal_log_softmax_out(
&self,
out: &Tensor,
dim: i64,
half_to_float: bool
) -> Result<Tensor, TchError>
pub fn f_internal_logcumsumexp(&self, dim: i64) -> Result<Tensor, TchError>
pub fn f_internal_logcumsumexp_out(
&self,
out: &Tensor,
dim: i64
) -> Result<Tensor, TchError>
pub fn f_internal_lu_with_info(
&self,
pivot: bool,
check_errors: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_internal_make_dual(
primal: &Tensor,
tangent: &Tensor,
level: i64
) -> Result<Tensor, TchError>
pub fn f_internal_make_per_channel_quantized_tensor(
&self,
scale: &Tensor,
zero_point: &Tensor,
axis: i64
) -> Result<Tensor, TchError>
pub fn f_internal_make_per_tensor_quantized_tensor(
&self,
scale: f64,
zero_point: i64
) -> Result<Tensor, TchError>
pub fn f_internal_masked_scale(
&self,
mask: &Tensor,
scale: f64
) -> Result<Tensor, TchError>
pub fn f_internal_masked_softmax(
&self,
mask: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_mkldnn_reshape(
&self,
shape: &[i64]
) -> Result<Tensor, TchError>
pub fn f_internal_mkldnn_transpose(
&self,
dim0: i64,
dim1: i64
) -> Result<Tensor, TchError>
pub fn f_internal_mkldnn_transpose_(
&mut self,
dim0: i64,
dim1: i64
) -> Result<Tensor, TchError>
pub fn f_internal_native_multi_head_self_attention<T: Borrow<Tensor>>(
query: &Tensor,
qkv_weight: &Tensor,
qkv_bias: &Tensor,
proj_weight: &Tensor,
proj_bias: &Tensor,
mask: Option<T>
) -> Result<Tensor, TchError>
pub fn f_internal_neg_view(&self) -> Result<Tensor, TchError>
pub fn f_internal_new_zeros_with_same_feature_meta(
&self,
other: &Tensor,
self_num_batch_dims: i64
) -> Result<Tensor, TchError>
pub fn f_internal_nnpack_available() -> Result<bool, TchError>
pub fn f_internal_nnpack_spatial_convolution<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
stride: &[i64]
) -> Result<Tensor, TchError>
pub fn f_internal_nnz(&self) -> Result<i64, TchError>
pub fn f_internal_pack_padded_sequence(
&self,
lengths: &Tensor,
batch_first: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_internal_pack_padded_sequence_backward(
grad: &Tensor,
input_size: &[i64],
batch_sizes: &Tensor,
batch_first: bool
) -> Result<Tensor, TchError>
pub fn f_internal_pad_packed_sequence<S: Into<Scalar>>(
data: &Tensor,
batch_sizes: &Tensor,
batch_first: bool,
padding_value: S,
total_length: i64
) -> Result<(Tensor, Tensor), TchError>
pub fn f_internal_pdist_backward(
&self,
grad: &Tensor,
p: f64,
pdist: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_pin_memory(&self, device: Device) -> Result<Tensor, TchError>
pub fn f_internal_remove_batch_dim(
&self,
level: i64,
batch_size: i64,
out_dim: i64
) -> Result<Tensor, TchError>
pub fn f_internal_reshape_alias(
&self,
size: &[i64],
stride: &[i64]
) -> Result<Tensor, TchError>
pub fn f_internal_reshape_from_tensor(
&self,
shape: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_rowwise_prune(
weight: &Tensor,
mask: &Tensor,
compressed_indices_dtype: Kind
) -> Result<(Tensor, Tensor), TchError>
pub fn f_internal_s_where(
&self,
condition: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_sample_dirichlet(&self) -> Result<Tensor, TchError>
pub fn f_internal_saturate_weight_to_fp16(
weight: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_segment_reduce_backward<T: Borrow<Tensor>>(
grad: &Tensor,
output: &Tensor,
data: &Tensor,
reduce: &str,
lengths: Option<T>,
axis: i64
) -> Result<Tensor, TchError>
pub fn f_internal_shape_as_tensor(&self) -> Result<Tensor, TchError>
pub fn f_internal_slow_conv2d_backward(
&self,
grad_input: &Tensor,
grad_weight: &Tensor,
grad_bias: &Tensor,
grad_output: &Tensor,
weight: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_internal_sobol_engine_draw(
quasi: &Tensor,
n: i64,
sobolstate: &Tensor,
dimension: i64,
num_generated: i64,
dtype: Kind
) -> Result<(Tensor, Tensor), TchError>
pub fn f_internal_sobol_engine_ff_(
&mut self,
n: i64,
sobolstate: &Tensor,
dimension: i64,
num_generated: i64
) -> Result<Tensor, TchError>
pub fn f_internal_sobol_engine_initialize_state_(
&mut self,
dimension: i64
) -> Result<Tensor, TchError>
pub fn f_internal_sobol_engine_scramble_(
&mut self,
ltm: &Tensor,
dimension: i64
) -> Result<Tensor, TchError>
pub fn f_internal_softmax(
&self,
dim: i64,
half_to_float: bool
) -> Result<Tensor, TchError>
pub fn f_internal_softmax_backward_data(
grad_output: &Tensor,
output: &Tensor,
dim: i64,
input_dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_internal_softmax_backward_data_out(
grad_input: &Tensor,
grad_output: &Tensor,
output: &Tensor,
dim: i64,
input_dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_internal_softmax_out(
&self,
out: &Tensor,
dim: i64,
half_to_float: bool
) -> Result<Tensor, TchError>
pub fn f_internal_solve_helper(
&self,
a: &Tensor
) -> Result<(Tensor, Tensor), TchError>
pub fn f_internal_sparse_addmm(
&self,
sparse: &Tensor,
dense: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_sparse_broadcast_to(
&self,
size: &[i64]
) -> Result<Tensor, TchError>
pub fn f_internal_sparse_coo_tensor_unsafe(
indices: &Tensor,
values: &Tensor,
size: &[i64],
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_internal_sparse_coo_tensor_with_dims(
sparse_dim: i64,
dense_dim: i64,
size: &[i64],
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_internal_sparse_coo_tensor_with_dims_and_tensors(
sparse_dim: i64,
dense_dim: i64,
size: &[i64],
indices: &Tensor,
values: &Tensor,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_internal_sparse_csr_tensor_unsafe(
crow_indices: &Tensor,
col_indices: &Tensor,
values: &Tensor,
size: &[i64],
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_internal_sparse_log_softmax(
&self,
dim: i64,
half_to_float: bool
) -> Result<Tensor, TchError>
pub fn f_internal_sparse_log_softmax_backward_data(
&self,
grad_output: &Tensor,
output: &Tensor,
dim: i64
) -> Result<Tensor, TchError>
pub fn f_internal_sparse_log_softmax_int(
&self,
dim: i64,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_internal_sparse_mask_helper(
tr: &Tensor,
mask_indices: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_sparse_mm(
sparse: &Tensor,
dense: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_sparse_softmax(
&self,
dim: i64,
half_to_float: bool
) -> Result<Tensor, TchError>
pub fn f_internal_sparse_softmax_backward_data(
&self,
grad_output: &Tensor,
output: &Tensor,
dim: i64
) -> Result<Tensor, TchError>
pub fn f_internal_sparse_softmax_int(
&self,
dim: i64,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_internal_sparse_sparse_matmul(
&self,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_sparse_sum(&self) -> Result<Tensor, TchError>
pub fn f_internal_sparse_sum_backward(
&self,
grad: &Tensor,
dim: &[i64]
) -> Result<Tensor, TchError>
pub fn f_internal_sparse_sum_dim(&self, dim: &[i64]) -> Result<Tensor, TchError>
pub fn f_internal_sparse_sum_dim_dtype(
&self,
dim: &[i64],
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_internal_sparse_sum_dtype(
&self,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_internal_stack<T: Borrow<Tensor>>(
tensors: &[T],
dim: i64
) -> Result<Tensor, TchError>
pub fn f_internal_stack_out<T: Borrow<Tensor>>(
out: &Tensor,
tensors: &[T],
dim: i64
) -> Result<Tensor, TchError>
pub fn f_internal_standard_gamma(&self) -> Result<Tensor, TchError>
pub fn f_internal_standard_gamma_grad(
&self,
output: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_symeig_helper(
&self,
eigenvectors: bool,
upper: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_internal_test_ambiguous_defaults(
dummy: &Tensor,
a: i64,
b: i64
) -> Result<Tensor, TchError>
pub fn f_internal_test_ambiguous_defaults_b(
dummy: &Tensor,
a: i64,
b: &str
) -> Result<Tensor, TchError>
pub fn f_internal_test_optional_filled_intlist<'a>(
values: &Tensor,
addends: impl Into<Option<&'a [i64]>>
) -> Result<Tensor, TchError>
pub fn f_internal_test_optional_floatlist(
values: &Tensor,
addends: &[f64]
) -> Result<Tensor, TchError>
pub fn f_internal_test_optional_intlist<'a>(
values: &Tensor,
addends: impl Into<Option<&'a [i64]>>
) -> Result<Tensor, TchError>
pub fn f_internal_test_serialization_subcmul(
&self,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_internal_test_string_default(
dummy: &Tensor,
a: &str,
b: &str
) -> Result<Tensor, TchError>
pub fn f_internal_test_warn_in_autograd(&self) -> Result<Tensor, TchError>
pub fn f_internal_to_copy(
&self,
options: (Kind, Device),
non_blocking: bool
) -> Result<Tensor, TchError>
pub fn f_internal_to_cpu<T: Borrow<Tensor>>(
tensors: &[T]
) -> Result<Vec<Tensor>, TchError>
pub fn f_internal_torch_cuda_cu_linker_symbol_op(
&self
) -> Result<Tensor, TchError>
pub fn f_internal_trilinear(
i1: &Tensor,
i2: &Tensor,
i3: &Tensor,
expand1: &[i64],
expand2: &[i64],
expand3: &[i64],
sumdim: &[i64],
unroll_dim: i64
) -> Result<Tensor, TchError>
pub fn f_internal_unique(
&self,
sorted: bool,
return_inverse: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_internal_unique2(
&self,
sorted: bool,
return_inverse: bool,
return_counts: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_internal_unpack_dual(
dual: &Tensor,
level: i64
) -> Result<(Tensor, Tensor), TchError>
pub fn f_internal_unsafe_view(&self, size: &[i64]) -> Result<Tensor, TchError>
pub fn f_internal_upsample_bicubic2d_aa(
&self,
output_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_bicubic2d_aa_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_bicubic2d_aa_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_bicubic2d_aa_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
align_corners: bool,
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_bicubic2d_aa_out(
&self,
out: &Tensor,
output_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_bicubic2d_aa_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
align_corners: bool,
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_bilinear2d_aa(
&self,
output_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_bilinear2d_aa_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_bilinear2d_aa_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_bilinear2d_aa_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
align_corners: bool,
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_bilinear2d_aa_out(
&self,
out: &Tensor,
output_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_bilinear2d_aa_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
align_corners: bool,
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_nearest_exact1d(
&self,
output_size: &[i64],
scales: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_nearest_exact1d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_nearest_exact1d_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_nearest_exact1d_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_nearest_exact1d_out(
&self,
out: &Tensor,
output_size: &[i64],
scales: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_nearest_exact1d_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_nearest_exact2d(
&self,
output_size: &[i64],
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_nearest_exact2d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_nearest_exact2d_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_nearest_exact2d_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_nearest_exact2d_out(
&self,
out: &Tensor,
output_size: &[i64],
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_nearest_exact2d_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_nearest_exact3d(
&self,
output_size: &[i64],
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_nearest_exact3d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_nearest_exact3d_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_nearest_exact3d_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_nearest_exact3d_out(
&self,
out: &Tensor,
output_size: &[i64],
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_internal_upsample_nearest_exact3d_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_internal_use_cudnn_ctc_loss(
log_probs: &Tensor,
targets: &Tensor,
input_lengths: &[i64],
target_lengths: &[i64],
blank: i64
) -> Result<bool, TchError>
pub fn f_internal_use_cudnn_rnn_flatten_weight() -> Result<bool, TchError>
pub fn f_internal_validate_sparse_csr_tensor_args(
crow_indices: &Tensor,
col_indices: &Tensor,
values: &Tensor,
size: &[i64]
) -> Result<(), TchError>
pub fn f_internal_values(&self) -> Result<Tensor, TchError>
pub fn f_internal_version(&self) -> Result<i64, TchError>
pub fn f_internal_weight_norm(
v: &Tensor,
g: &Tensor,
dim: i64
) -> Result<Tensor, TchError>
pub fn f_internal_weight_norm_cuda_interface(
v: &Tensor,
g: &Tensor,
dim: i64
) -> Result<(Tensor, Tensor), TchError>
pub fn f_internal_weight_norm_cuda_interface_backward(
grad_w: &Tensor,
saved_v: &Tensor,
saved_g: &Tensor,
saved_norms: &Tensor,
dim: i64
) -> Result<(Tensor, Tensor), TchError>
pub fn f_internal_weight_norm_differentiable_backward(
grad_w: &Tensor,
saved_v: &Tensor,
saved_g: &Tensor,
saved_norms: &Tensor,
dim: i64
) -> Result<(Tensor, Tensor), TchError>
pub fn f_abs(&self) -> Result<Tensor, TchError>
pub fn f_abs_(&mut self) -> Result<Tensor, TchError>
pub fn f_abs_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_absolute(&self) -> Result<Tensor, TchError>
pub fn f_absolute_(&mut self) -> Result<Tensor, TchError>
pub fn f_absolute_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_acos(&self) -> Result<Tensor, TchError>
pub fn f_acos_(&mut self) -> Result<Tensor, TchError>
pub fn f_acos_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_acosh(&self) -> Result<Tensor, TchError>
pub fn f_acosh_(&mut self) -> Result<Tensor, TchError>
pub fn f_acosh_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_adaptive_avg_pool1d(
&self,
output_size: &[i64]
) -> Result<Tensor, TchError>
pub fn f_adaptive_avg_pool2d(
&self,
output_size: &[i64]
) -> Result<Tensor, TchError>
pub fn f_adaptive_avg_pool2d_out(
&self,
out: &Tensor,
output_size: &[i64]
) -> Result<Tensor, TchError>
pub fn f_adaptive_avg_pool3d(
&self,
output_size: &[i64]
) -> Result<Tensor, TchError>
pub fn f_adaptive_avg_pool3d_backward(
&self,
grad_input: &Tensor,
grad_output: &Tensor
) -> Result<Tensor, TchError>
pub fn f_adaptive_avg_pool3d_out(
&self,
out: &Tensor,
output_size: &[i64]
) -> Result<Tensor, TchError>
pub fn f_adaptive_max_pool1d(
&self,
output_size: &[i64]
) -> Result<(Tensor, Tensor), TchError>
pub fn f_adaptive_max_pool2d(
&self,
output_size: &[i64]
) -> Result<(Tensor, Tensor), TchError>
pub fn f_adaptive_max_pool2d_backward(
&self,
grad_output: &Tensor,
indices: &Tensor
) -> Result<Tensor, TchError>
pub fn f_adaptive_max_pool2d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor
) -> Result<Tensor, TchError>
pub fn f_adaptive_max_pool2d_out(
&self,
out: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Result<(Tensor, Tensor), TchError>
pub fn f_adaptive_max_pool3d(
&self,
output_size: &[i64]
) -> Result<(Tensor, Tensor), TchError>
pub fn f_adaptive_max_pool3d_backward(
&self,
grad_output: &Tensor,
indices: &Tensor
) -> Result<Tensor, TchError>
pub fn f_adaptive_max_pool3d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor
) -> Result<Tensor, TchError>
pub fn f_adaptive_max_pool3d_out(
&self,
out: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Result<(Tensor, Tensor), TchError>
pub fn f_add(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_add_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_add_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_add_scalar<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_add_scalar_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_addbmm(
&self,
batch1: &Tensor,
batch2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_addbmm_(
&mut self,
batch1: &Tensor,
batch2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_addbmm_out(
&self,
out: &Tensor,
batch1: &Tensor,
batch2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_addcdiv(
&self,
tensor1: &Tensor,
tensor2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_addcdiv_(
&mut self,
tensor1: &Tensor,
tensor2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_addcdiv_out(
&self,
out: &Tensor,
tensor1: &Tensor,
tensor2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_addcmul(
&self,
tensor1: &Tensor,
tensor2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_addcmul_(
&mut self,
tensor1: &Tensor,
tensor2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_addcmul_out(
&self,
out: &Tensor,
tensor1: &Tensor,
tensor2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_addmm(&self, mat1: &Tensor, mat2: &Tensor) -> Result<Tensor, TchError>
pub fn f_addmm_(
&mut self,
mat1: &Tensor,
mat2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_addmm_out(
&self,
out: &Tensor,
mat1: &Tensor,
mat2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_addmv(&self, mat: &Tensor, vec: &Tensor) -> Result<Tensor, TchError>
pub fn f_addmv_(
&mut self,
mat: &Tensor,
vec: &Tensor
) -> Result<Tensor, TchError>
pub fn f_addmv_out(
&self,
out: &Tensor,
mat: &Tensor,
vec: &Tensor
) -> Result<Tensor, TchError>
pub fn f_addr(&self, vec1: &Tensor, vec2: &Tensor) -> Result<Tensor, TchError>
pub fn f_addr_(
&mut self,
vec1: &Tensor,
vec2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_addr_out(
&self,
out: &Tensor,
vec1: &Tensor,
vec2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_adjoint(&self) -> Result<Tensor, TchError>
pub fn f_affine_grid_generator(
theta: &Tensor,
size: &[i64],
align_corners: bool
) -> Result<Tensor, TchError>
pub fn f_affine_grid_generator_backward(
grad: &Tensor,
size: &[i64],
align_corners: bool
) -> Result<Tensor, TchError>
pub fn f_alias(&self) -> Result<Tensor, TchError>
pub fn f_align_as(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_align_tensors<T: Borrow<Tensor>>(
tensors: &[T]
) -> Result<Vec<Tensor>, TchError>
pub fn f_all(&self) -> Result<Tensor, TchError>
pub fn f_all_all_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_all_dim(&self, dim: i64, keepdim: bool) -> Result<Tensor, TchError>
pub fn f_all_out(
&self,
out: &Tensor,
dim: i64,
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_allclose(
&self,
other: &Tensor,
rtol: f64,
atol: f64,
equal_nan: bool
) -> Result<bool, TchError>
pub fn f_alpha_dropout(&self, p: f64, train: bool) -> Result<Tensor, TchError>
pub fn f_alpha_dropout_(
&mut self,
p: f64,
train: bool
) -> Result<Tensor, TchError>
pub fn f_amax(&self, dim: &[i64], keepdim: bool) -> Result<Tensor, TchError>
pub fn f_amax_out(
&self,
out: &Tensor,
dim: &[i64],
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_amin(&self, dim: &[i64], keepdim: bool) -> Result<Tensor, TchError>
pub fn f_amin_out(
&self,
out: &Tensor,
dim: &[i64],
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_aminmax(
&self,
dim: impl Into<Option<i64>>,
keepdim: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_aminmax_out(
&self,
min: &Tensor,
max: &Tensor,
dim: impl Into<Option<i64>>,
keepdim: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_angle(&self) -> Result<Tensor, TchError>
pub fn f_angle_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_any(&self) -> Result<Tensor, TchError>
pub fn f_any_all_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_any_dim(&self, dim: i64, keepdim: bool) -> Result<Tensor, TchError>
pub fn f_any_out(
&self,
out: &Tensor,
dim: i64,
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_arange<S: Into<Scalar>>(
end: S,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_arange_out<S: Into<Scalar>>(
out: &Tensor,
end: S
) -> Result<Tensor, TchError>
pub fn f_arange_start<S: Into<Scalar>>(
start: S,
end: S,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_arange_start_out<S: Into<Scalar>>(
out: &Tensor,
start: S,
end: S
) -> Result<Tensor, TchError>
pub fn f_arange_start_step<S: Into<Scalar>>(
start: S,
end: S,
step: S,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_arccos(&self) -> Result<Tensor, TchError>
pub fn f_arccos_(&mut self) -> Result<Tensor, TchError>
pub fn f_arccos_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_arccosh(&self) -> Result<Tensor, TchError>
pub fn f_arccosh_(&mut self) -> Result<Tensor, TchError>
pub fn f_arccosh_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_arcsin(&self) -> Result<Tensor, TchError>
pub fn f_arcsin_(&mut self) -> Result<Tensor, TchError>
pub fn f_arcsin_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_arcsinh(&self) -> Result<Tensor, TchError>
pub fn f_arcsinh_(&mut self) -> Result<Tensor, TchError>
pub fn f_arcsinh_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_arctan(&self) -> Result<Tensor, TchError>
pub fn f_arctan2(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_arctan2_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_arctan2_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_arctan_(&mut self) -> Result<Tensor, TchError>
pub fn f_arctan_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_arctanh(&self) -> Result<Tensor, TchError>
pub fn f_arctanh_(&mut self) -> Result<Tensor, TchError>
pub fn f_arctanh_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_argmax(
&self,
dim: impl Into<Option<i64>>,
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_argmax_out(
&self,
out: &Tensor,
dim: impl Into<Option<i64>>,
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_argmin(
&self,
dim: impl Into<Option<i64>>,
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_argmin_out(
&self,
out: &Tensor,
dim: impl Into<Option<i64>>,
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_argsort(&self, dim: i64, descending: bool) -> Result<Tensor, TchError>
pub fn f_argwhere(&self) -> Result<Tensor, TchError>
pub fn f_as_strided(
&self,
size: &[i64],
stride: &[i64],
storage_offset: impl Into<Option<i64>>
) -> Result<Tensor, TchError>
pub fn f_as_strided_(
&mut self,
size: &[i64],
stride: &[i64],
storage_offset: impl Into<Option<i64>>
) -> Result<Tensor, TchError>
pub fn f_asin(&self) -> Result<Tensor, TchError>
pub fn f_asin_(&mut self) -> Result<Tensor, TchError>
pub fn f_asin_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_asinh(&self) -> Result<Tensor, TchError>
pub fn f_asinh_(&mut self) -> Result<Tensor, TchError>
pub fn f_asinh_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_atan(&self) -> Result<Tensor, TchError>
pub fn f_atan2(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_atan2_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_atan2_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_atan_(&mut self) -> Result<Tensor, TchError>
pub fn f_atan_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_atanh(&self) -> Result<Tensor, TchError>
pub fn f_atanh_(&mut self) -> Result<Tensor, TchError>
pub fn f_atanh_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_atleast_1d(&self) -> Result<Tensor, TchError>
pub fn f_atleast_1d_sequence<T: Borrow<Tensor>>(
tensors: &[T]
) -> Result<Vec<Tensor>, TchError>
pub fn f_atleast_2d(&self) -> Result<Tensor, TchError>
pub fn f_atleast_2d_sequence<T: Borrow<Tensor>>(
tensors: &[T]
) -> Result<Vec<Tensor>, TchError>
pub fn f_atleast_3d(&self) -> Result<Tensor, TchError>
pub fn f_atleast_3d_sequence<T: Borrow<Tensor>>(
tensors: &[T]
) -> Result<Vec<Tensor>, TchError>
pub fn f_avg_pool1d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Result<Tensor, TchError>
pub fn f_avg_pool2d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool,
divisor_override: impl Into<Option<i64>>
) -> Result<Tensor, TchError>
pub fn f_avg_pool2d_backward(
&self,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool,
divisor_override: impl Into<Option<i64>>
) -> Result<Tensor, TchError>
pub fn f_avg_pool2d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool,
divisor_override: impl Into<Option<i64>>
) -> Result<Tensor, TchError>
pub fn f_avg_pool2d_out(
&self,
out: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool,
divisor_override: impl Into<Option<i64>>
) -> Result<Tensor, TchError>
pub fn f_avg_pool3d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool,
divisor_override: impl Into<Option<i64>>
) -> Result<Tensor, TchError>
pub fn f_avg_pool3d_backward(
&self,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool,
divisor_override: impl Into<Option<i64>>
) -> Result<Tensor, TchError>
pub fn f_avg_pool3d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool,
divisor_override: impl Into<Option<i64>>
) -> Result<Tensor, TchError>
pub fn f_avg_pool3d_out(
&self,
out: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool,
divisor_override: impl Into<Option<i64>>
) -> Result<Tensor, TchError>
pub fn f_baddbmm(
&self,
batch1: &Tensor,
batch2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_baddbmm_(
&mut self,
batch1: &Tensor,
batch2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_baddbmm_out(
&self,
out: &Tensor,
batch1: &Tensor,
batch2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_bartlett_window(
window_length: i64,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_bartlett_window_periodic(
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_batch_norm<T: Borrow<Tensor>>(
&self,
weight: Option<T>,
bias: Option<T>,
running_mean: Option<T>,
running_var: Option<T>,
training: bool,
momentum: f64,
eps: f64,
cudnn_enabled: bool
) -> Result<Tensor, TchError>
pub fn f_batch_norm_backward_elemt<T: Borrow<Tensor>>(
&self,
grad_out: &Tensor,
mean: &Tensor,
invstd: &Tensor,
weight: Option<T>,
mean_dy: &Tensor,
mean_dy_xmu: &Tensor,
count: &Tensor
) -> Result<Tensor, TchError>
pub fn f_batch_norm_backward_reduce<T: Borrow<Tensor>>(
&self,
grad_out: &Tensor,
mean: &Tensor,
invstd: &Tensor,
weight: Option<T>,
input_g: bool,
weight_g: bool,
bias_g: bool
) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>
pub fn f_batch_norm_elemt<T: Borrow<Tensor>>(
&self,
weight: Option<T>,
bias: Option<T>,
mean: &Tensor,
invstd: &Tensor,
eps: f64
) -> Result<Tensor, TchError>
pub fn f_batch_norm_elemt_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
weight: Option<T>,
bias: Option<T>,
mean: &Tensor,
invstd: &Tensor,
eps: f64
) -> Result<Tensor, TchError>
pub fn f_batch_norm_gather_stats<T: Borrow<Tensor>>(
&self,
mean: &Tensor,
invstd: &Tensor,
running_mean: Option<T>,
running_var: Option<T>,
momentum: f64,
eps: f64,
count: i64
) -> Result<(Tensor, Tensor), TchError>
pub fn f_batch_norm_gather_stats_with_counts<T: Borrow<Tensor>>(
&self,
mean: &Tensor,
invstd: &Tensor,
running_mean: Option<T>,
running_var: Option<T>,
momentum: f64,
eps: f64,
counts: &Tensor
) -> Result<(Tensor, Tensor), TchError>
pub fn f_batch_norm_stats(&self, eps: f64) -> Result<(Tensor, Tensor), TchError>
pub fn f_batch_norm_update_stats<T: Borrow<Tensor>>(
&self,
running_mean: Option<T>,
running_var: Option<T>,
momentum: f64
) -> Result<(Tensor, Tensor), TchError>
pub fn f_bernoulli(&self) -> Result<Tensor, TchError>
pub fn f_bernoulli_(&mut self, p: &Tensor) -> Result<Tensor, TchError>
pub fn f_bernoulli_float_(&mut self, p: f64) -> Result<Tensor, TchError>
pub fn f_bernoulli_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_bernoulli_p(&self, p: f64) -> Result<Tensor, TchError>
pub fn f_bilinear<T: Borrow<Tensor>>(
input1: &Tensor,
input2: &Tensor,
weight: &Tensor,
bias: Option<T>
) -> Result<Tensor, TchError>
pub fn f_binary_cross_entropy<T: Borrow<Tensor>>(
&self,
target: &Tensor,
weight: Option<T>,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_binary_cross_entropy_backward<T: Borrow<Tensor>>(
&self,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_binary_cross_entropy_backward_grad_input<T: Borrow<Tensor>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_binary_cross_entropy_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_binary_cross_entropy_with_logits<T: Borrow<Tensor>>(
&self,
target: &Tensor,
weight: Option<T>,
pos_weight: Option<T>,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_binary_cross_entropy_with_logits_backward<T: Borrow<Tensor>>(
&self,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
pos_weight: Option<T>,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_bincount<T: Borrow<Tensor>>(
&self,
weights: Option<T>,
minlength: i64
) -> Result<Tensor, TchError>
pub fn f_binomial(count: &Tensor, prob: &Tensor) -> Result<Tensor, TchError>
pub fn f_bitwise_and<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_bitwise_and_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_bitwise_and_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_bitwise_and_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_bitwise_and_tensor_(
&mut self,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_bitwise_and_tensor_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_bitwise_left_shift(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_bitwise_left_shift_(
&mut self,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_bitwise_left_shift_scalar_tensor<S: Into<Scalar>>(
self_scalar: S,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_bitwise_left_shift_tensor_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_bitwise_left_shift_tensor_scalar<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_bitwise_left_shift_tensor_scalar_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_bitwise_left_shift_tensor_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_bitwise_not(&self) -> Result<Tensor, TchError>
pub fn f_bitwise_not_(&mut self) -> Result<Tensor, TchError>
pub fn f_bitwise_not_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_bitwise_or<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_bitwise_or_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_bitwise_or_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_bitwise_or_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_bitwise_or_tensor_(
&mut self,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_bitwise_or_tensor_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_bitwise_right_shift(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_bitwise_right_shift_(
&mut self,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_bitwise_right_shift_scalar_tensor<S: Into<Scalar>>(
self_scalar: S,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_bitwise_right_shift_tensor_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_bitwise_right_shift_tensor_scalar<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_bitwise_right_shift_tensor_scalar_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_bitwise_right_shift_tensor_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_bitwise_xor<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_bitwise_xor_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_bitwise_xor_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_bitwise_xor_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_bitwise_xor_tensor_(
&mut self,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_bitwise_xor_tensor_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_blackman_window(
window_length: i64,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_blackman_window_periodic(
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_block_diag<T: Borrow<Tensor>>(
tensors: &[T]
) -> Result<Tensor, TchError>
pub fn f_bmm(&self, mat2: &Tensor) -> Result<Tensor, TchError>
pub fn f_bmm_out(&self, out: &Tensor, mat2: &Tensor) -> Result<Tensor, TchError>
pub fn f_broadcast_tensors<T: Borrow<Tensor>>(
tensors: &[T]
) -> Result<Vec<Tensor>, TchError>
pub fn f_broadcast_to(&self, size: &[i64]) -> Result<Tensor, TchError>
pub fn f_bucketize(
&self,
boundaries: &Tensor,
out_int32: bool,
right: bool
) -> Result<Tensor, TchError>
pub fn f_bucketize_scalar<S: Into<Scalar>>(
self_scalar: S,
boundaries: &Tensor,
out_int32: bool,
right: bool
) -> Result<Tensor, TchError>
pub fn f_bucketize_tensor_out(
&self,
out: &Tensor,
boundaries: &Tensor,
out_int32: bool,
right: bool
) -> Result<Tensor, TchError>
pub fn f_can_cast(from: Kind, to: Kind) -> Result<bool, TchError>
pub fn f_cartesian_prod<T: Borrow<Tensor>>(
tensors: &[T]
) -> Result<Tensor, TchError>
pub fn f_cat<T: Borrow<Tensor>>(
tensors: &[T],
dim: i64
) -> Result<Tensor, TchError>
pub fn f_cat_out<T: Borrow<Tensor>>(
out: &Tensor,
tensors: &[T],
dim: i64
) -> Result<Tensor, TchError>
pub fn f_cauchy_(&mut self, median: f64, sigma: f64) -> Result<Tensor, TchError>
pub fn f_cdist(
x1: &Tensor,
x2: &Tensor,
p: f64,
compute_mode: impl Into<Option<i64>>
) -> Result<Tensor, TchError>
pub fn f_ceil(&self) -> Result<Tensor, TchError>
pub fn f_ceil_(&mut self) -> Result<Tensor, TchError>
pub fn f_ceil_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_celu(&self) -> Result<Tensor, TchError>
pub fn f_celu_(&mut self) -> Result<Tensor, TchError>
pub fn f_chain_matmul<T: Borrow<Tensor>>(
matrices: &[T]
) -> Result<Tensor, TchError>
pub fn f_chain_matmul_out<T: Borrow<Tensor>>(
out: &Tensor,
matrices: &[T]
) -> Result<Tensor, TchError>
pub fn f_channel_shuffle(&self, groups: i64) -> Result<Tensor, TchError>
pub fn f_cholesky(&self, upper: bool) -> Result<Tensor, TchError>
pub fn f_cholesky_inverse(&self, upper: bool) -> Result<Tensor, TchError>
pub fn f_cholesky_inverse_out(
&self,
out: &Tensor,
upper: bool
) -> Result<Tensor, TchError>
pub fn f_cholesky_out(
&self,
out: &Tensor,
upper: bool
) -> Result<Tensor, TchError>
pub fn f_cholesky_solve(
&self,
input2: &Tensor,
upper: bool
) -> Result<Tensor, TchError>
pub fn f_cholesky_solve_out(
&self,
out: &Tensor,
input2: &Tensor,
upper: bool
) -> Result<Tensor, TchError>
pub fn f_choose_qparams_optimized(
&self,
numel: i64,
n_bins: i64,
ratio: f64,
bit_width: i64
) -> Result<(Tensor, Tensor), TchError>
pub fn f_chunk(&self, chunks: i64, dim: i64) -> Result<Vec<Tensor>, TchError>
pub fn f_clamp<S: Into<Scalar>>(
&self,
min: S,
max: S
) -> Result<Tensor, TchError>
pub fn f_clamp_<S: Into<Scalar>>(
&mut self,
min: S,
max: S
) -> Result<Tensor, TchError>
pub fn f_clamp_max<S: Into<Scalar>>(&self, max: S) -> Result<Tensor, TchError>
pub fn f_clamp_max_<S: Into<Scalar>>(
&mut self,
max: S
) -> Result<Tensor, TchError>
pub fn f_clamp_max_out<S: Into<Scalar>>(
&self,
out: &Tensor,
max: S
) -> Result<Tensor, TchError>
pub fn f_clamp_max_tensor(&self, max: &Tensor) -> Result<Tensor, TchError>
pub fn f_clamp_max_tensor_(&mut self, max: &Tensor) -> Result<Tensor, TchError>
pub fn f_clamp_max_tensor_out(
&self,
out: &Tensor,
max: &Tensor
) -> Result<Tensor, TchError>
pub fn f_clamp_min<S: Into<Scalar>>(&self, min: S) -> Result<Tensor, TchError>
pub fn f_clamp_min_<S: Into<Scalar>>(
&mut self,
min: S
) -> Result<Tensor, TchError>
pub fn f_clamp_min_out<S: Into<Scalar>>(
&self,
out: &Tensor,
min: S
) -> Result<Tensor, TchError>
pub fn f_clamp_min_tensor(&self, min: &Tensor) -> Result<Tensor, TchError>
pub fn f_clamp_min_tensor_(&mut self, min: &Tensor) -> Result<Tensor, TchError>
pub fn f_clamp_min_tensor_out(
&self,
out: &Tensor,
min: &Tensor
) -> Result<Tensor, TchError>
pub fn f_clamp_out<S: Into<Scalar>>(
&self,
out: &Tensor,
min: S,
max: S
) -> Result<Tensor, TchError>
pub fn f_clamp_tensor<T: Borrow<Tensor>>(
&self,
min: Option<T>,
max: Option<T>
) -> Result<Tensor, TchError>
pub fn f_clamp_tensor_<T: Borrow<Tensor>>(
&mut self,
min: Option<T>,
max: Option<T>
) -> Result<Tensor, TchError>
pub fn f_clamp_tensor_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
min: Option<T>,
max: Option<T>
) -> Result<Tensor, TchError>
pub fn f_clip<S: Into<Scalar>>(
&self,
min: S,
max: S
) -> Result<Tensor, TchError>
pub fn f_clip_<S: Into<Scalar>>(
&mut self,
min: S,
max: S
) -> Result<Tensor, TchError>
pub fn f_clip_out<S: Into<Scalar>>(
&self,
out: &Tensor,
min: S,
max: S
) -> Result<Tensor, TchError>
pub fn f_clip_tensor<T: Borrow<Tensor>>(
&self,
min: Option<T>,
max: Option<T>
) -> Result<Tensor, TchError>
pub fn f_clip_tensor_<T: Borrow<Tensor>>(
&mut self,
min: Option<T>,
max: Option<T>
) -> Result<Tensor, TchError>
pub fn f_clip_tensor_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
min: Option<T>,
max: Option<T>
) -> Result<Tensor, TchError>
pub fn f_coalesce(&self) -> Result<Tensor, TchError>
pub fn f_col2im(
&self,
output_size: &[i64],
kernel_size: &[i64],
dilation: &[i64],
padding: &[i64],
stride: &[i64]
) -> Result<Tensor, TchError>
pub fn f_col2im_backward(
grad_output: &Tensor,
kernel_size: &[i64],
dilation: &[i64],
padding: &[i64],
stride: &[i64]
) -> Result<Tensor, TchError>
pub fn f_col2im_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
dilation: &[i64],
padding: &[i64],
stride: &[i64]
) -> Result<Tensor, TchError>
pub fn f_col2im_out(
&self,
out: &Tensor,
output_size: &[i64],
kernel_size: &[i64],
dilation: &[i64],
padding: &[i64],
stride: &[i64]
) -> Result<Tensor, TchError>
pub fn f_col_indices(&self) -> Result<Tensor, TchError>
pub fn f_column_stack<T: Borrow<Tensor>>(
tensors: &[T]
) -> Result<Tensor, TchError>
pub fn f_column_stack_out<T: Borrow<Tensor>>(
out: &Tensor,
tensors: &[T]
) -> Result<Tensor, TchError>
pub fn f_combinations(
&self,
r: i64,
with_replacement: bool
) -> Result<Tensor, TchError>
pub fn f_complex(real: &Tensor, imag: &Tensor) -> Result<Tensor, TchError>
pub fn f_complex_out(
out: &Tensor,
real: &Tensor,
imag: &Tensor
) -> Result<Tensor, TchError>
pub fn f_concat<T: Borrow<Tensor>>(
tensors: &[T],
dim: i64
) -> Result<Tensor, TchError>
pub fn f_concat_out<T: Borrow<Tensor>>(
out: &Tensor,
tensors: &[T],
dim: i64
) -> Result<Tensor, TchError>
pub fn f_conj(&self) -> Result<Tensor, TchError>
pub fn f_conj_physical(&self) -> Result<Tensor, TchError>
pub fn f_conj_physical_(&mut self) -> Result<Tensor, TchError>
pub fn f_conj_physical_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_constant_pad_nd(&self, pad: &[i64]) -> Result<Tensor, TchError>
pub fn f_contiguous(&self) -> Result<Tensor, TchError>
pub fn f_conv1d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
groups: i64
) -> Result<Tensor, TchError>
pub fn f_conv1d_padding<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &str,
dilation: &[i64],
groups: i64
) -> Result<Tensor, TchError>
pub fn f_conv2d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
groups: i64
) -> Result<Tensor, TchError>
pub fn f_conv2d_padding<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &str,
dilation: &[i64],
groups: i64
) -> Result<Tensor, TchError>
pub fn f_conv3d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
groups: i64
) -> Result<Tensor, TchError>
pub fn f_conv3d_padding<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &str,
dilation: &[i64],
groups: i64
) -> Result<Tensor, TchError>
pub fn f_conv_depthwise3d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
kernel_size: &[i64],
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64]
) -> Result<Tensor, TchError>
pub fn f_conv_tbc(
&self,
weight: &Tensor,
bias: &Tensor,
pad: i64
) -> Result<Tensor, TchError>
pub fn f_conv_tbc_backward(
&self,
input: &Tensor,
weight: &Tensor,
bias: &Tensor,
pad: i64
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_conv_transpose1d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
groups: i64,
dilation: &[i64]
) -> Result<Tensor, TchError>
pub fn f_conv_transpose2d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
groups: i64,
dilation: &[i64]
) -> Result<Tensor, TchError>
pub fn f_conv_transpose3d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
groups: i64,
dilation: &[i64]
) -> Result<Tensor, TchError>
pub fn f_convolution<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
transposed: bool,
output_padding: &[i64],
groups: i64
) -> Result<Tensor, TchError>
pub fn f_convolution_overrideable<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
transposed: bool,
output_padding: &[i64],
groups: i64
) -> Result<Tensor, TchError>
pub fn f_copy_sparse_to_sparse_(
&mut self,
src: &Tensor,
non_blocking: bool
) -> Result<Tensor, TchError>
pub fn f_copysign(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_copysign_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_copysign_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_copysign_scalar<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_copysign_scalar_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_copysign_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_corrcoef(&self) -> Result<Tensor, TchError>
pub fn f_cos(&self) -> Result<Tensor, TchError>
pub fn f_cos_(&mut self) -> Result<Tensor, TchError>
pub fn f_cos_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_cosh(&self) -> Result<Tensor, TchError>
pub fn f_cosh_(&mut self) -> Result<Tensor, TchError>
pub fn f_cosh_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_cosine_embedding_loss(
input1: &Tensor,
input2: &Tensor,
target: &Tensor,
margin: f64,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_cosine_similarity(
x1: &Tensor,
x2: &Tensor,
dim: i64,
eps: f64
) -> Result<Tensor, TchError>
pub fn f_count_nonzero(
&self,
dim: impl Into<Option<i64>>
) -> Result<Tensor, TchError>
pub fn f_count_nonzero_dim_intlist(
&self,
dim: &[i64]
) -> Result<Tensor, TchError>
pub fn f_cov<T: Borrow<Tensor>>(
&self,
correction: i64,
fweights: Option<T>,
aweights: Option<T>
) -> Result<Tensor, TchError>
pub fn f_cross(
&self,
other: &Tensor,
dim: impl Into<Option<i64>>
) -> Result<Tensor, TchError>
pub fn f_cross_entropy_loss<T: Borrow<Tensor>>(
&self,
target: &Tensor,
weight: Option<T>,
reduction: Reduction,
ignore_index: i64,
label_smoothing: f64
) -> Result<Tensor, TchError>
pub fn f_cross_out(
&self,
out: &Tensor,
other: &Tensor,
dim: impl Into<Option<i64>>
) -> Result<Tensor, TchError>
pub fn f_crow_indices(&self) -> Result<Tensor, TchError>
pub fn f_ctc_loss(
log_probs: &Tensor,
targets: &Tensor,
input_lengths: &[i64],
target_lengths: &[i64],
blank: i64,
reduction: Reduction,
zero_infinity: bool
) -> Result<Tensor, TchError>
pub fn f_ctc_loss_tensor(
log_probs: &Tensor,
targets: &Tensor,
input_lengths: &Tensor,
target_lengths: &Tensor,
blank: i64,
reduction: Reduction,
zero_infinity: bool
) -> Result<Tensor, TchError>
pub fn f_cudnn_affine_grid_generator(
theta: &Tensor,
n: i64,
c: i64,
h: i64,
w: i64
) -> Result<Tensor, TchError>
pub fn f_cudnn_affine_grid_generator_backward(
grad: &Tensor,
n: i64,
c: i64,
h: i64,
w: i64
) -> Result<Tensor, TchError>
pub fn f_cudnn_batch_norm<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
running_mean: Option<T>,
running_var: Option<T>,
training: bool,
exponential_average_factor: f64,
epsilon: f64
) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>
pub fn f_cudnn_batch_norm_backward<T: Borrow<Tensor>>(
&self,
grad_output: &Tensor,
weight: &Tensor,
running_mean: Option<T>,
running_var: Option<T>,
save_mean: Option<T>,
save_var: Option<T>,
epsilon: f64,
reservespace: &Tensor
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_cudnn_convolution(
&self,
weight: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool,
allow_tf32: bool
) -> Result<Tensor, TchError>
pub fn f_cudnn_convolution_add_relu<T: Borrow<Tensor>, S: Into<Scalar>>(
&self,
weight: &Tensor,
z: &Tensor,
alpha: S,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
groups: i64
) -> Result<Tensor, TchError>
pub fn f_cudnn_convolution_relu<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
groups: i64
) -> Result<Tensor, TchError>
pub fn f_cudnn_convolution_transpose(
&self,
weight: &Tensor,
padding: &[i64],
output_padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool,
allow_tf32: bool
) -> Result<Tensor, TchError>
pub fn f_cudnn_grid_sampler(&self, grid: &Tensor) -> Result<Tensor, TchError>
pub fn f_cudnn_grid_sampler_backward(
&self,
grid: &Tensor,
grad_output: &Tensor
) -> Result<(Tensor, Tensor), TchError>
pub fn f_cudnn_is_acceptable(&self) -> Result<bool, TchError>
pub fn f_cummax(&self, dim: i64) -> Result<(Tensor, Tensor), TchError>
pub fn f_cummax_out(
&self,
values: &Tensor,
indices: &Tensor,
dim: i64
) -> Result<(Tensor, Tensor), TchError>
pub fn f_cummaxmin_backward(
&self,
grad: &Tensor,
indices: &Tensor,
dim: i64
) -> Result<Tensor, TchError>
pub fn f_cummin(&self, dim: i64) -> Result<(Tensor, Tensor), TchError>
pub fn f_cummin_out(
&self,
values: &Tensor,
indices: &Tensor,
dim: i64
) -> Result<(Tensor, Tensor), TchError>
pub fn f_cumprod(&self, dim: i64, dtype: Kind) -> Result<Tensor, TchError>
pub fn f_cumprod_(&mut self, dim: i64, dtype: Kind) -> Result<Tensor, TchError>
pub fn f_cumprod_backward(
&self,
grad: &Tensor,
dim: i64,
output: &Tensor
) -> Result<Tensor, TchError>
pub fn f_cumprod_out(
&self,
out: &Tensor,
dim: i64,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_cumsum(&self, dim: i64, dtype: Kind) -> Result<Tensor, TchError>
pub fn f_cumsum_(&mut self, dim: i64, dtype: Kind) -> Result<Tensor, TchError>
pub fn f_cumsum_out(
&self,
out: &Tensor,
dim: i64,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_cumulative_trapezoid(y: &Tensor, dim: i64) -> Result<Tensor, TchError>
pub fn f_cumulative_trapezoid_x(
y: &Tensor,
x: &Tensor,
dim: i64
) -> Result<Tensor, TchError>
pub fn f_data(&self) -> Result<Tensor, TchError>
pub fn f_deg2rad(&self) -> Result<Tensor, TchError>
pub fn f_deg2rad_(&mut self) -> Result<Tensor, TchError>
pub fn f_deg2rad_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_dense_dim(&self) -> Result<i64, TchError>
pub fn f_dequantize(&self) -> Result<Tensor, TchError>
pub fn f_dequantize_tensors<T: Borrow<Tensor>>(
tensors: &[T]
) -> Result<Vec<Tensor>, TchError>
pub fn f_det(&self) -> Result<Tensor, TchError>
pub fn f_detach(&self) -> Result<Tensor, TchError>
pub fn f_detach_(&mut self) -> Result<Tensor, TchError>
pub fn f_diag(&self, diagonal: i64) -> Result<Tensor, TchError>
pub fn f_diag_backward(
grad: &Tensor,
input_sizes: &[i64],
diagonal: i64
) -> Result<Tensor, TchError>
pub fn f_diag_embed(
&self,
offset: i64,
dim1: i64,
dim2: i64
) -> Result<Tensor, TchError>
pub fn f_diag_out(
&self,
out: &Tensor,
diagonal: i64
) -> Result<Tensor, TchError>
pub fn f_diagflat(&self, offset: i64) -> Result<Tensor, TchError>
pub fn f_diagonal(
&self,
offset: i64,
dim1: i64,
dim2: i64
) -> Result<Tensor, TchError>
pub fn f_diagonal_backward(
grad_output: &Tensor,
input_sizes: &[i64],
offset: i64,
dim1: i64,
dim2: i64
) -> Result<Tensor, TchError>
pub fn f_diagonal_scatter(
&self,
src: &Tensor,
offset: i64,
dim1: i64,
dim2: i64
) -> Result<Tensor, TchError>
pub fn f_diff<T: Borrow<Tensor>>(
&self,
n: i64,
dim: i64,
prepend: Option<T>,
append: Option<T>
) -> Result<Tensor, TchError>
pub fn f_diff_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
n: i64,
dim: i64,
prepend: Option<T>,
append: Option<T>
) -> Result<Tensor, TchError>
pub fn f_digamma(&self) -> Result<Tensor, TchError>
pub fn f_digamma_(&mut self) -> Result<Tensor, TchError>
pub fn f_digamma_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_dist(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_div(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_div_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_div_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_div_out_mode(
&self,
out: &Tensor,
other: &Tensor,
rounding_mode: &str
) -> Result<Tensor, TchError>
pub fn f_div_scalar<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_div_scalar_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_div_scalar_mode<S: Into<Scalar>>(
&self,
other: S,
rounding_mode: &str
) -> Result<Tensor, TchError>
pub fn f_div_scalar_mode_<S: Into<Scalar>>(
&mut self,
other: S,
rounding_mode: &str
) -> Result<Tensor, TchError>
pub fn f_div_tensor_mode(
&self,
other: &Tensor,
rounding_mode: &str
) -> Result<Tensor, TchError>
pub fn f_div_tensor_mode_(
&mut self,
other: &Tensor,
rounding_mode: &str
) -> Result<Tensor, TchError>
pub fn f_divide(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_divide_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_divide_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_divide_out_mode(
&self,
out: &Tensor,
other: &Tensor,
rounding_mode: &str
) -> Result<Tensor, TchError>
pub fn f_divide_scalar<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_divide_scalar_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_divide_scalar_mode<S: Into<Scalar>>(
&self,
other: S,
rounding_mode: &str
) -> Result<Tensor, TchError>
pub fn f_divide_scalar_mode_<S: Into<Scalar>>(
&mut self,
other: S,
rounding_mode: &str
) -> Result<Tensor, TchError>
pub fn f_divide_tensor_mode(
&self,
other: &Tensor,
rounding_mode: &str
) -> Result<Tensor, TchError>
pub fn f_divide_tensor_mode_(
&mut self,
other: &Tensor,
rounding_mode: &str
) -> Result<Tensor, TchError>
pub fn f_dot(&self, tensor: &Tensor) -> Result<Tensor, TchError>
pub fn f_dot_out(
&self,
out: &Tensor,
tensor: &Tensor
) -> Result<Tensor, TchError>
pub fn f_dropout(&self, p: f64, train: bool) -> Result<Tensor, TchError>
pub fn f_dropout_(&mut self, p: f64, train: bool) -> Result<Tensor, TchError>
pub fn f_dsplit(&self, sections: i64) -> Result<Vec<Tensor>, TchError>
pub fn f_dsplit_array(&self, indices: &[i64]) -> Result<Vec<Tensor>, TchError>
pub fn f_dstack<T: Borrow<Tensor>>(tensors: &[T]) -> Result<Tensor, TchError>
pub fn f_dstack_out<T: Borrow<Tensor>>(
out: &Tensor,
tensors: &[T]
) -> Result<Tensor, TchError>
pub fn f_eig(&self, eigenvectors: bool) -> Result<(Tensor, Tensor), TchError>
pub fn f_eig_e(
&self,
e: &Tensor,
v: &Tensor,
eigenvectors: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_einsum<T: Borrow<Tensor>>(
equation: &str,
tensors: &[T]
) -> Result<Tensor, TchError>
pub fn f_elu(&self) -> Result<Tensor, TchError>
pub fn f_elu_(&mut self) -> Result<Tensor, TchError>
pub fn f_elu_backward<S: Into<Scalar>>(
grad_output: &Tensor,
alpha: S,
scale: S,
input_scale: S,
is_result: bool,
self_or_result: &Tensor
) -> Result<Tensor, TchError>
pub fn f_elu_backward_grad_input<S: Into<Scalar>>(
grad_input: &Tensor,
grad_output: &Tensor,
alpha: S,
scale: S,
input_scale: S,
is_result: bool,
self_or_result: &Tensor
) -> Result<Tensor, TchError>
pub fn f_elu_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_embedding(
weight: &Tensor,
indices: &Tensor,
padding_idx: i64,
scale_grad_by_freq: bool,
sparse: bool
) -> Result<Tensor, TchError>
pub fn f_embedding_backward(
grad: &Tensor,
indices: &Tensor,
num_weights: i64,
padding_idx: i64,
scale_grad_by_freq: bool,
sparse: bool
) -> Result<Tensor, TchError>
pub fn f_embedding_bag<T: Borrow<Tensor>>(
weight: &Tensor,
indices: &Tensor,
offsets: &Tensor,
scale_grad_by_freq: bool,
mode: i64,
sparse: bool,
per_sample_weights: Option<T>,
include_last_offset: bool
) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>
pub fn f_embedding_bag_padding_idx<T: Borrow<Tensor>>(
weight: &Tensor,
indices: &Tensor,
offsets: &Tensor,
scale_grad_by_freq: bool,
mode: i64,
sparse: bool,
per_sample_weights: Option<T>,
include_last_offset: bool,
padding_idx: impl Into<Option<i64>>
) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>
pub fn f_embedding_dense_backward(
grad_output: &Tensor,
indices: &Tensor,
num_weights: i64,
padding_idx: i64,
scale_grad_by_freq: bool
) -> Result<Tensor, TchError>
pub fn f_embedding_renorm_(
&mut self,
indices: &Tensor,
max_norm: f64,
norm_type: f64
) -> Result<Tensor, TchError>
pub fn f_embedding_sparse_backward(
grad: &Tensor,
indices: &Tensor,
num_weights: i64,
padding_idx: i64,
scale_grad_by_freq: bool
) -> Result<Tensor, TchError>
pub fn f_empty(
size: &[i64],
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_empty_like(&self) -> Result<Tensor, TchError>
pub fn f_empty_out(out: &Tensor, size: &[i64]) -> Result<Tensor, TchError>
pub fn f_empty_quantized(
size: &[i64],
qtensor: &Tensor,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_empty_strided(
size: &[i64],
stride: &[i64],
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_eq<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>
pub fn f_eq_<S: Into<Scalar>>(&mut self, other: S) -> Result<Tensor, TchError>
pub fn f_eq_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_eq_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_eq_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_eq_tensor_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_equal(&self, other: &Tensor) -> Result<bool, TchError>
pub fn f_erf(&self) -> Result<Tensor, TchError>
pub fn f_erf_(&mut self) -> Result<Tensor, TchError>
pub fn f_erf_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_erfc(&self) -> Result<Tensor, TchError>
pub fn f_erfc_(&mut self) -> Result<Tensor, TchError>
pub fn f_erfc_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_erfinv(&self) -> Result<Tensor, TchError>
pub fn f_erfinv_(&mut self) -> Result<Tensor, TchError>
pub fn f_erfinv_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_exp(&self) -> Result<Tensor, TchError>
pub fn f_exp2(&self) -> Result<Tensor, TchError>
pub fn f_exp2_(&mut self) -> Result<Tensor, TchError>
pub fn f_exp2_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_exp_(&mut self) -> Result<Tensor, TchError>
pub fn f_exp_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_expand(&self, size: &[i64], implicit: bool) -> Result<Tensor, TchError>
pub fn f_expand_as(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_expm1(&self) -> Result<Tensor, TchError>
pub fn f_expm1_(&mut self) -> Result<Tensor, TchError>
pub fn f_expm1_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_exponential_(&mut self, lambd: f64) -> Result<Tensor, TchError>
pub fn f_eye(n: i64, options: (Kind, Device)) -> Result<Tensor, TchError>
pub fn f_eye_m(
n: i64,
m: i64,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_eye_m_out(out: &Tensor, n: i64, m: i64) -> Result<Tensor, TchError>
pub fn f_eye_out(out: &Tensor, n: i64) -> Result<Tensor, TchError>
pub fn f_fake_quantize_per_channel_affine(
&self,
scale: &Tensor,
zero_point: &Tensor,
axis: i64,
quant_min: i64,
quant_max: i64
) -> Result<Tensor, TchError>
pub fn f_fake_quantize_per_channel_affine_cachemask(
&self,
scale: &Tensor,
zero_point: &Tensor,
axis: i64,
quant_min: i64,
quant_max: i64
) -> Result<(Tensor, Tensor), TchError>
pub fn f_fake_quantize_per_channel_affine_cachemask_backward(
grad: &Tensor,
mask: &Tensor
) -> Result<Tensor, TchError>
pub fn f_fake_quantize_per_tensor_affine(
&self,
scale: f64,
zero_point: i64,
quant_min: i64,
quant_max: i64
) -> Result<Tensor, TchError>
pub fn f_fake_quantize_per_tensor_affine_cachemask(
&self,
scale: f64,
zero_point: i64,
quant_min: i64,
quant_max: i64
) -> Result<(Tensor, Tensor), TchError>
pub fn f_fake_quantize_per_tensor_affine_cachemask_backward(
grad: &Tensor,
mask: &Tensor
) -> Result<Tensor, TchError>
pub fn f_fake_quantize_per_tensor_affine_tensor_qparams(
&self,
scale: &Tensor,
zero_point: &Tensor,
quant_min: i64,
quant_max: i64
) -> Result<Tensor, TchError>
pub fn f_fbgemm_linear_fp16_weight(
&self,
packed_weight: &Tensor,
bias: &Tensor
) -> Result<Tensor, TchError>
pub fn f_fbgemm_linear_fp16_weight_fp32_activation(
&self,
packed_weight: &Tensor,
bias: &Tensor
) -> Result<Tensor, TchError>
pub fn f_fbgemm_linear_int8_weight<S: Into<Scalar>>(
&self,
weight: &Tensor,
packed: &Tensor,
col_offsets: &Tensor,
weight_scale: S,
weight_zero_point: S,
bias: &Tensor
) -> Result<Tensor, TchError>
pub fn f_fbgemm_linear_int8_weight_fp32_activation<S: Into<Scalar>>(
&self,
weight: &Tensor,
packed: &Tensor,
col_offsets: &Tensor,
weight_scale: S,
weight_zero_point: S,
bias: &Tensor
) -> Result<Tensor, TchError>
pub fn f_fbgemm_pack_gemm_matrix_fp16(&self) -> Result<Tensor, TchError>
pub fn f_fbgemm_pack_quantized_matrix(&self) -> Result<Tensor, TchError>
pub fn f_fbgemm_pack_quantized_matrix_kn(
&self,
k: i64,
n: i64
) -> Result<Tensor, TchError>
pub fn f_feature_alpha_dropout(
&self,
p: f64,
train: bool
) -> Result<Tensor, TchError>
pub fn f_feature_alpha_dropout_(
&mut self,
p: f64,
train: bool
) -> Result<Tensor, TchError>
pub fn f_feature_dropout(&self, p: f64, train: bool) -> Result<Tensor, TchError>
pub fn f_feature_dropout_(
&mut self,
p: f64,
train: bool
) -> Result<Tensor, TchError>
pub fn f_fft_fft(
&self,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_fft2<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_fft2_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_fft_out(
&self,
out: &Tensor,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_fftfreq(
n: i64,
d: f64,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_fft_fftfreq_out(
out: &Tensor,
n: i64,
d: f64
) -> Result<Tensor, TchError>
pub fn f_fft_fftn<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_fftn_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_fftshift<'a>(
&self,
dim: impl Into<Option<&'a [i64]>>
) -> Result<Tensor, TchError>
pub fn f_fft_hfft(
&self,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_hfft2<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_hfft2_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_hfft_out(
&self,
out: &Tensor,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_hfftn<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_hfftn_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_ifft(
&self,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_ifft2<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_ifft2_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_ifft_out(
&self,
out: &Tensor,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_ifftn<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_ifftn_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_ifftshift<'a>(
&self,
dim: impl Into<Option<&'a [i64]>>
) -> Result<Tensor, TchError>
pub fn f_fft_ihfft(
&self,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_ihfft2<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_ihfft2_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_ihfft_out(
&self,
out: &Tensor,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_ihfftn<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_ihfftn_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_irfft(
&self,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_irfft2<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_irfft2_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_irfft_out(
&self,
out: &Tensor,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_irfftn<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_irfftn_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_rfft(
&self,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_rfft2<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_rfft2_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_rfft_out(
&self,
out: &Tensor,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_rfftfreq(
n: i64,
d: f64,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_fft_rfftfreq_out(
out: &Tensor,
n: i64,
d: f64
) -> Result<Tensor, TchError>
pub fn f_fft_rfftn<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fft_rfftn_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Result<Tensor, TchError>
pub fn f_fill_<S: Into<Scalar>>(&mut self, value: S) -> Result<Tensor, TchError>
pub fn f_fill_diagonal_<S: Into<Scalar>>(
&mut self,
fill_value: S,
wrap: bool
) -> Result<Tensor, TchError>
pub fn f_fill_tensor_(&mut self, value: &Tensor) -> Result<Tensor, TchError>
pub fn f_fix(&self) -> Result<Tensor, TchError>
pub fn f_fix_(&mut self) -> Result<Tensor, TchError>
pub fn f_fix_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_flatten(
&self,
start_dim: i64,
end_dim: i64
) -> Result<Tensor, TchError>
pub fn f_flatten_dense_tensors<T: Borrow<Tensor>>(
tensors: &[T]
) -> Result<Tensor, TchError>
pub fn f_flip(&self, dims: &[i64]) -> Result<Tensor, TchError>
pub fn f_fliplr(&self) -> Result<Tensor, TchError>
pub fn f_flipud(&self) -> Result<Tensor, TchError>
pub fn f_float_power(&self, exponent: &Tensor) -> Result<Tensor, TchError>
pub fn f_float_power_<S: Into<Scalar>>(
&mut self,
exponent: S
) -> Result<Tensor, TchError>
pub fn f_float_power_scalar<S: Into<Scalar>>(
self_scalar: S,
exponent: &Tensor
) -> Result<Tensor, TchError>
pub fn f_float_power_scalar_out<S: Into<Scalar>>(
out: &Tensor,
self_scalar: S,
exponent: &Tensor
) -> Result<Tensor, TchError>
pub fn f_float_power_tensor_(
&mut self,
exponent: &Tensor
) -> Result<Tensor, TchError>
pub fn f_float_power_tensor_scalar<S: Into<Scalar>>(
&self,
exponent: S
) -> Result<Tensor, TchError>
pub fn f_float_power_tensor_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
exponent: S
) -> Result<Tensor, TchError>
pub fn f_float_power_tensor_tensor_out(
&self,
out: &Tensor,
exponent: &Tensor
) -> Result<Tensor, TchError>
pub fn f_floor(&self) -> Result<Tensor, TchError>
pub fn f_floor_(&mut self) -> Result<Tensor, TchError>
pub fn f_floor_divide(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_floor_divide_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_floor_divide_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_floor_divide_scalar<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_floor_divide_scalar_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_floor_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_fmax(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_fmax_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_fmin(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_fmin_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_fmod<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>
pub fn f_fmod_<S: Into<Scalar>>(&mut self, other: S) -> Result<Tensor, TchError>
pub fn f_fmod_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_fmod_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_fmod_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_fmod_tensor_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_frac(&self) -> Result<Tensor, TchError>
pub fn f_frac_(&mut self) -> Result<Tensor, TchError>
pub fn f_frac_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_fractional_max_pool2d(
&self,
kernel_size: &[i64],
output_size: &[i64],
random_samples: &Tensor
) -> Result<(Tensor, Tensor), TchError>
pub fn f_fractional_max_pool2d_backward(
&self,
grad_output: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
indices: &Tensor
) -> Result<Tensor, TchError>
pub fn f_fractional_max_pool2d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
indices: &Tensor
) -> Result<Tensor, TchError>
pub fn f_fractional_max_pool2d_output(
&self,
output: &Tensor,
indices: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
random_samples: &Tensor
) -> Result<(Tensor, Tensor), TchError>
pub fn f_fractional_max_pool3d(
&self,
kernel_size: &[i64],
output_size: &[i64],
random_samples: &Tensor
) -> Result<(Tensor, Tensor), TchError>
pub fn f_fractional_max_pool3d_backward(
&self,
grad_output: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
indices: &Tensor
) -> Result<Tensor, TchError>
pub fn f_fractional_max_pool3d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
indices: &Tensor
) -> Result<Tensor, TchError>
pub fn f_fractional_max_pool3d_output(
&self,
output: &Tensor,
indices: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
random_samples: &Tensor
) -> Result<(Tensor, Tensor), TchError>
pub fn f_frexp(&self) -> Result<(Tensor, Tensor), TchError>
pub fn f_frexp_tensor_out(
&self,
mantissa: &Tensor,
exponent: &Tensor
) -> Result<(Tensor, Tensor), TchError>
pub fn f_frobenius_norm(&self) -> Result<Tensor, TchError>
pub fn f_frobenius_norm_dim(
&self,
dim: &[i64],
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_frobenius_norm_out(
&self,
out: &Tensor,
dim: &[i64],
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_from_file(
filename: &str,
shared: bool,
size: impl Into<Option<i64>>,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_full<S: Into<Scalar>>(
size: &[i64],
fill_value: S,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_full_like<S: Into<Scalar>>(
&self,
fill_value: S
) -> Result<Tensor, TchError>
pub fn f_full_out<S: Into<Scalar>>(
out: &Tensor,
size: &[i64],
fill_value: S
) -> Result<Tensor, TchError>
pub fn f_fused_moving_avg_obs_fake_quant(
&self,
observer_on: &Tensor,
fake_quant_on: &Tensor,
running_min: &Tensor,
running_max: &Tensor,
scale: &Tensor,
zero_point: &Tensor,
averaging_const: f64,
quant_min: i64,
quant_max: i64,
ch_axis: i64,
per_row_fake_quant: bool,
symmetric_quant: bool
) -> Result<Tensor, TchError>
pub fn f_gather(
&self,
dim: i64,
index: &Tensor,
sparse_grad: bool
) -> Result<Tensor, TchError>
pub fn f_gather_backward(
&self,
grad: &Tensor,
dim: i64,
index: &Tensor,
sparse_grad: bool
) -> Result<Tensor, TchError>
pub fn f_gather_out(
&self,
out: &Tensor,
dim: i64,
index: &Tensor,
sparse_grad: bool
) -> Result<Tensor, TchError>
pub fn f_gcd(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_gcd_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_gcd_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_ge<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>
pub fn f_ge_<S: Into<Scalar>>(&mut self, other: S) -> Result<Tensor, TchError>
pub fn f_ge_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_ge_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_ge_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_ge_tensor_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_gelu(&self) -> Result<Tensor, TchError>
pub fn f_gelu_backward(&self, grad: &Tensor) -> Result<Tensor, TchError>
pub fn f_gelu_backward_grad_input(
&self,
grad_input: &Tensor,
grad: &Tensor
) -> Result<Tensor, TchError>
pub fn f_gelu_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_geometric_(&mut self, p: f64) -> Result<Tensor, TchError>
pub fn f_geqrf(&self) -> Result<(Tensor, Tensor), TchError>
pub fn f_geqrf_a(
&self,
a: &Tensor,
tau: &Tensor
) -> Result<(Tensor, Tensor), TchError>
pub fn f_ger(&self, vec2: &Tensor) -> Result<Tensor, TchError>
pub fn f_ger_out(&self, out: &Tensor, vec2: &Tensor) -> Result<Tensor, TchError>
pub fn f_glu(&self, dim: i64) -> Result<Tensor, TchError>
pub fn f_glu_backward(
&self,
grad_output: &Tensor,
dim: i64
) -> Result<Tensor, TchError>
pub fn f_glu_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
dim: i64
) -> Result<Tensor, TchError>
pub fn f_glu_out(&self, out: &Tensor, dim: i64) -> Result<Tensor, TchError>
pub fn f_grad(&self) -> Result<Tensor, TchError>
pub fn f_greater<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>
pub fn f_greater_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_greater_equal<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_greater_equal_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_greater_equal_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_greater_equal_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_greater_equal_tensor_(
&mut self,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_greater_equal_tensor_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_greater_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_greater_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_greater_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_greater_tensor_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_grid_sampler(
&self,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64,
align_corners: bool
) -> Result<Tensor, TchError>
pub fn f_grid_sampler_2d(
&self,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64,
align_corners: bool
) -> Result<Tensor, TchError>
pub fn f_grid_sampler_3d(
&self,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64,
align_corners: bool
) -> Result<Tensor, TchError>
pub fn f_grid_sampler_3d_backward(
&self,
grad_output: &Tensor,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64,
align_corners: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_group_norm<T: Borrow<Tensor>>(
&self,
num_groups: i64,
weight: Option<T>,
bias: Option<T>,
eps: f64,
cudnn_enabled: bool
) -> Result<Tensor, TchError>
pub fn f_gru<T: Borrow<Tensor>>(
&self,
hx: &Tensor,
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool,
batch_first: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_gru_cell<T: Borrow<Tensor>>(
&self,
hx: &Tensor,
w_ih: &Tensor,
w_hh: &Tensor,
b_ih: Option<T>,
b_hh: Option<T>
) -> Result<Tensor, TchError>
pub fn f_gru_data<T: Borrow<Tensor>>(
data: &Tensor,
batch_sizes: &Tensor,
hx: &Tensor,
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_gt<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>
pub fn f_gt_<S: Into<Scalar>>(&mut self, other: S) -> Result<Tensor, TchError>
pub fn f_gt_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_gt_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_gt_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_gt_tensor_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_hamming_window(
window_length: i64,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_hamming_window_periodic(
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_hamming_window_periodic_alpha(
window_length: i64,
periodic: bool,
alpha: f64,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_hamming_window_periodic_alpha_beta(
window_length: i64,
periodic: bool,
alpha: f64,
beta: f64,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_hann_window(
window_length: i64,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_hann_window_periodic(
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_hardshrink(&self) -> Result<Tensor, TchError>
pub fn f_hardshrink_backward<S: Into<Scalar>>(
&self,
grad_out: &Tensor,
lambd: S
) -> Result<Tensor, TchError>
pub fn f_hardshrink_backward_grad_input<S: Into<Scalar>>(
&self,
grad_input: &Tensor,
grad_out: &Tensor,
lambd: S
) -> Result<Tensor, TchError>
pub fn f_hardshrink_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_hardsigmoid(&self) -> Result<Tensor, TchError>
pub fn f_hardsigmoid_(&mut self) -> Result<Tensor, TchError>
pub fn f_hardsigmoid_backward(
&self,
grad_output: &Tensor
) -> Result<Tensor, TchError>
pub fn f_hardsigmoid_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor
) -> Result<Tensor, TchError>
pub fn f_hardsigmoid_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_hardswish(&self) -> Result<Tensor, TchError>
pub fn f_hardswish_(&mut self) -> Result<Tensor, TchError>
pub fn f_hardswish_backward(
&self,
grad_output: &Tensor
) -> Result<Tensor, TchError>
pub fn f_hardswish_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_hardtanh(&self) -> Result<Tensor, TchError>
pub fn f_hardtanh_(&mut self) -> Result<Tensor, TchError>
pub fn f_hardtanh_backward<S: Into<Scalar>>(
&self,
grad_output: &Tensor,
min_val: S,
max_val: S
) -> Result<Tensor, TchError>
pub fn f_hardtanh_backward_grad_input<S: Into<Scalar>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
min_val: S,
max_val: S
) -> Result<Tensor, TchError>
pub fn f_hardtanh_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_heaviside(&self, values: &Tensor) -> Result<Tensor, TchError>
pub fn f_heaviside_(&mut self, values: &Tensor) -> Result<Tensor, TchError>
pub fn f_heaviside_out(
&self,
out: &Tensor,
values: &Tensor
) -> Result<Tensor, TchError>
pub fn f_hinge_embedding_loss(
&self,
target: &Tensor,
margin: f64,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_histc(&self, bins: i64) -> Result<Tensor, TchError>
pub fn f_histc_out(&self, out: &Tensor, bins: i64) -> Result<Tensor, TchError>
pub fn f_histogram<T: Borrow<Tensor>>(
&self,
bins: &Tensor,
weight: Option<T>,
density: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_histogram_bin_ct<T: Borrow<Tensor>>(
&self,
bins: i64,
range: &[f64],
weight: Option<T>,
density: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_histogram_bin_ct_out<T: Borrow<Tensor>>(
&self,
hist: &Tensor,
bin_edges: &Tensor,
bins: i64,
range: &[f64],
weight: Option<T>,
density: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_histogram_bins_tensor_out<T: Borrow<Tensor>>(
&self,
hist: &Tensor,
bin_edges: &Tensor,
bins: &Tensor,
weight: Option<T>,
density: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_hsplit(&self, sections: i64) -> Result<Vec<Tensor>, TchError>
pub fn f_hsplit_array(&self, indices: &[i64]) -> Result<Vec<Tensor>, TchError>
pub fn f_hspmm(mat1: &Tensor, mat2: &Tensor) -> Result<Tensor, TchError>
pub fn f_hspmm_out(
out: &Tensor,
mat1: &Tensor,
mat2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_hstack<T: Borrow<Tensor>>(tensors: &[T]) -> Result<Tensor, TchError>
pub fn f_hstack_out<T: Borrow<Tensor>>(
out: &Tensor,
tensors: &[T]
) -> Result<Tensor, TchError>
pub fn f_huber_loss(
&self,
target: &Tensor,
reduction: Reduction,
delta: f64
) -> Result<Tensor, TchError>
pub fn f_huber_loss_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction,
delta: f64
) -> Result<Tensor, TchError>
pub fn f_huber_loss_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction,
delta: f64
) -> Result<Tensor, TchError>
pub fn f_huber_loss_out(
&self,
out: &Tensor,
target: &Tensor,
reduction: Reduction,
delta: f64
) -> Result<Tensor, TchError>
pub fn f_hypot(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_hypot_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_hypot_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_i0(&self) -> Result<Tensor, TchError>
pub fn f_i0_(&mut self) -> Result<Tensor, TchError>
pub fn f_i0_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_igamma(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_igamma_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_igamma_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_igammac(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_igammac_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_igammac_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_im2col(
&self,
kernel_size: &[i64],
dilation: &[i64],
padding: &[i64],
stride: &[i64]
) -> Result<Tensor, TchError>
pub fn f_im2col_backward(
grad_output: &Tensor,
input_size: &[i64],
kernel_size: &[i64],
dilation: &[i64],
padding: &[i64],
stride: &[i64]
) -> Result<Tensor, TchError>
pub fn f_im2col_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
input_size: &[i64],
kernel_size: &[i64],
dilation: &[i64],
padding: &[i64],
stride: &[i64]
) -> Result<Tensor, TchError>
pub fn f_im2col_out(
&self,
out: &Tensor,
kernel_size: &[i64],
dilation: &[i64],
padding: &[i64],
stride: &[i64]
) -> Result<Tensor, TchError>
pub fn f_imag(&self) -> Result<Tensor, TchError>
pub fn f_index<T: Borrow<Tensor>>(
&self,
indices: &[Option<T>]
) -> Result<Tensor, TchError>
pub fn f_index_add(
&self,
dim: i64,
index: &Tensor,
source: &Tensor
) -> Result<Tensor, TchError>
pub fn f_index_add_(
&mut self,
dim: i64,
index: &Tensor,
source: &Tensor
) -> Result<Tensor, TchError>
pub fn f_index_add_out(
&self,
out: &Tensor,
dim: i64,
index: &Tensor,
source: &Tensor
) -> Result<Tensor, TchError>
pub fn f_index_copy(
&self,
dim: i64,
index: &Tensor,
source: &Tensor
) -> Result<Tensor, TchError>
pub fn f_index_copy_(
&mut self,
dim: i64,
index: &Tensor,
source: &Tensor
) -> Result<Tensor, TchError>
pub fn f_index_fill<S: Into<Scalar>>(
&self,
dim: i64,
index: &Tensor,
value: S
) -> Result<Tensor, TchError>
pub fn f_index_fill_<S: Into<Scalar>>(
&mut self,
dim: i64,
index: &Tensor,
value: S
) -> Result<Tensor, TchError>
pub fn f_index_fill_int_tensor(
&self,
dim: i64,
index: &Tensor,
value: &Tensor
) -> Result<Tensor, TchError>
pub fn f_index_fill_int_tensor_(
&mut self,
dim: i64,
index: &Tensor,
value: &Tensor
) -> Result<Tensor, TchError>
pub fn f_index_put<T: Borrow<Tensor>>(
&self,
indices: &[Option<T>],
values: &Tensor,
accumulate: bool
) -> Result<Tensor, TchError>
pub fn f_index_put_<T: Borrow<Tensor>>(
&mut self,
indices: &[Option<T>],
values: &Tensor,
accumulate: bool
) -> Result<Tensor, TchError>
pub fn f_index_select(
&self,
dim: i64,
index: &Tensor
) -> Result<Tensor, TchError>
pub fn f_index_select_backward(
grad: &Tensor,
self_sizes: &[i64],
dim: i64,
index: &Tensor
) -> Result<Tensor, TchError>
pub fn f_index_select_out(
&self,
out: &Tensor,
dim: i64,
index: &Tensor
) -> Result<Tensor, TchError>
pub fn f_indices(&self) -> Result<Tensor, TchError>
pub fn f_infinitely_differentiable_gelu_backward(
&self,
grad: &Tensor
) -> Result<Tensor, TchError>
pub fn f_inner(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_inner_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_instance_norm<T: Borrow<Tensor>>(
&self,
weight: Option<T>,
bias: Option<T>,
running_mean: Option<T>,
running_var: Option<T>,
use_input_stats: bool,
momentum: f64,
eps: f64,
cudnn_enabled: bool
) -> Result<Tensor, TchError>
pub fn f_int_repr(&self) -> Result<Tensor, TchError>
pub fn f_inverse(&self) -> Result<Tensor, TchError>
pub fn f_inverse_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_is_coalesced(&self) -> Result<bool, TchError>
pub fn f_is_complex(&self) -> Result<bool, TchError>
pub fn f_is_conj(&self) -> Result<bool, TchError>
pub fn f_is_distributed(&self) -> Result<bool, TchError>
pub fn f_is_floating_point(&self) -> Result<bool, TchError>
pub fn f_is_inference(&self) -> Result<bool, TchError>
pub fn f_is_leaf(&self) -> Result<bool, TchError>
pub fn f_is_neg(&self) -> Result<bool, TchError>
pub fn f_is_nonzero(&self) -> Result<bool, TchError>
pub fn f_is_pinned(&self, device: Device) -> Result<bool, TchError>
pub fn f_is_same_size(&self, other: &Tensor) -> Result<bool, TchError>
pub fn f_is_set_to(&self, tensor: &Tensor) -> Result<bool, TchError>
pub fn f_is_signed(&self) -> Result<bool, TchError>
pub fn f_is_vulkan_available() -> Result<bool, TchError>
pub fn f_isclose(
&self,
other: &Tensor,
rtol: f64,
atol: f64,
equal_nan: bool
) -> Result<Tensor, TchError>
pub fn f_isfinite(&self) -> Result<Tensor, TchError>
pub fn f_isin(
elements: &Tensor,
test_elements: &Tensor,
assume_unique: bool,
invert: bool
) -> Result<Tensor, TchError>
pub fn f_isin_scalar_tensor<S: Into<Scalar>>(
element: S,
test_elements: &Tensor,
assume_unique: bool,
invert: bool
) -> Result<Tensor, TchError>
pub fn f_isin_scalar_tensor_out<S: Into<Scalar>>(
out: &Tensor,
element: S,
test_elements: &Tensor,
assume_unique: bool,
invert: bool
) -> Result<Tensor, TchError>
pub fn f_isin_tensor_scalar<S: Into<Scalar>>(
elements: &Tensor,
test_element: S,
assume_unique: bool,
invert: bool
) -> Result<Tensor, TchError>
pub fn f_isin_tensor_scalar_out<S: Into<Scalar>>(
out: &Tensor,
elements: &Tensor,
test_element: S,
assume_unique: bool,
invert: bool
) -> Result<Tensor, TchError>
pub fn f_isin_tensor_tensor_out(
out: &Tensor,
elements: &Tensor,
test_elements: &Tensor,
assume_unique: bool,
invert: bool
) -> Result<Tensor, TchError>
pub fn f_isinf(&self) -> Result<Tensor, TchError>
pub fn f_isnan(&self) -> Result<Tensor, TchError>
pub fn f_isneginf(&self) -> Result<Tensor, TchError>
pub fn f_isneginf_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_isposinf(&self) -> Result<Tensor, TchError>
pub fn f_isposinf_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_isreal(&self) -> Result<Tensor, TchError>
pub fn f_istft<T: Borrow<Tensor>>(
&self,
n_fft: i64,
hop_length: impl Into<Option<i64>>,
win_length: impl Into<Option<i64>>,
window: Option<T>,
center: bool,
normalized: bool,
onesided: bool,
length: impl Into<Option<i64>>,
return_complex: bool
) -> Result<Tensor, TchError>
pub fn f_kaiser_window(
window_length: i64,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_kaiser_window_beta(
window_length: i64,
periodic: bool,
beta: f64,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_kaiser_window_periodic(
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_kl_div(
&self,
target: &Tensor,
reduction: Reduction,
log_target: bool
) -> Result<Tensor, TchError>
pub fn f_kl_div_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction,
log_target: bool
) -> Result<Tensor, TchError>
pub fn f_kron(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_kron_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_kthvalue(
&self,
k: i64,
dim: i64,
keepdim: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_kthvalue_values(
&self,
values: &Tensor,
indices: &Tensor,
k: i64,
dim: i64,
keepdim: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_l1_loss(
&self,
target: &Tensor,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_l1_loss_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_l1_loss_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_l1_loss_out(
&self,
out: &Tensor,
target: &Tensor,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_layer_norm<T: Borrow<Tensor>>(
&self,
normalized_shape: &[i64],
weight: Option<T>,
bias: Option<T>,
eps: f64,
cudnn_enable: bool
) -> Result<Tensor, TchError>
pub fn f_lcm(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_lcm_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_lcm_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_ldexp(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_ldexp_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_ldexp_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_le<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>
pub fn f_le_<S: Into<Scalar>>(&mut self, other: S) -> Result<Tensor, TchError>
pub fn f_le_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_le_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_le_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_le_tensor_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_leaky_relu(&self) -> Result<Tensor, TchError>
pub fn f_leaky_relu_(&mut self) -> Result<Tensor, TchError>
pub fn f_leaky_relu_backward<S: Into<Scalar>>(
&self,
grad_output: &Tensor,
negative_slope: S,
self_is_result: bool
) -> Result<Tensor, TchError>
pub fn f_leaky_relu_backward_grad_input<S: Into<Scalar>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
negative_slope: S,
self_is_result: bool
) -> Result<Tensor, TchError>
pub fn f_leaky_relu_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_lerp<S: Into<Scalar>>(
&self,
end: &Tensor,
weight: S
) -> Result<Tensor, TchError>
pub fn f_lerp_<S: Into<Scalar>>(
&mut self,
end: &Tensor,
weight: S
) -> Result<Tensor, TchError>
pub fn f_lerp_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
end: &Tensor,
weight: S
) -> Result<Tensor, TchError>
pub fn f_lerp_tensor(
&self,
end: &Tensor,
weight: &Tensor
) -> Result<Tensor, TchError>
pub fn f_lerp_tensor_(
&mut self,
end: &Tensor,
weight: &Tensor
) -> Result<Tensor, TchError>
pub fn f_lerp_tensor_out(
&self,
out: &Tensor,
end: &Tensor,
weight: &Tensor
) -> Result<Tensor, TchError>
pub fn f_less<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>
pub fn f_less_<S: Into<Scalar>>(&mut self, other: S) -> Result<Tensor, TchError>
pub fn f_less_equal<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_less_equal_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_less_equal_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_less_equal_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_less_equal_tensor_(
&mut self,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_less_equal_tensor_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_less_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_less_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_less_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_less_tensor_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_lgamma(&self) -> Result<Tensor, TchError>
pub fn f_lgamma_(&mut self) -> Result<Tensor, TchError>
pub fn f_lgamma_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_linalg_cholesky(&self, upper: bool) -> Result<Tensor, TchError>
pub fn f_linalg_cholesky_ex(
&self,
upper: bool,
check_errors: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_linalg_cholesky_ex_l(
&self,
l: &Tensor,
info: &Tensor,
upper: bool,
check_errors: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_linalg_cholesky_out(
&self,
out: &Tensor,
upper: bool
) -> Result<Tensor, TchError>
pub fn f_linalg_cond<S: Into<Scalar>>(&self, p: S) -> Result<Tensor, TchError>
pub fn f_linalg_cond_out<S: Into<Scalar>>(
&self,
out: &Tensor,
p: S
) -> Result<Tensor, TchError>
pub fn f_linalg_cond_p_str(&self, p: &str) -> Result<Tensor, TchError>
pub fn f_linalg_cond_p_str_out(
&self,
out: &Tensor,
p: &str
) -> Result<Tensor, TchError>
pub fn f_linalg_cross(
&self,
other: &Tensor,
dim: i64
) -> Result<Tensor, TchError>
pub fn f_linalg_cross_out(
&self,
out: &Tensor,
other: &Tensor,
dim: i64
) -> Result<Tensor, TchError>
pub fn f_linalg_det(&self) -> Result<Tensor, TchError>
pub fn f_linalg_det_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_linalg_diagonal(
a: &Tensor,
offset: i64,
dim1: i64,
dim2: i64
) -> Result<Tensor, TchError>
pub fn f_linalg_eig(&self) -> Result<(Tensor, Tensor), TchError>
pub fn f_linalg_eig_out(
&self,
eigenvalues: &Tensor,
eigenvectors: &Tensor
) -> Result<(Tensor, Tensor), TchError>
pub fn f_linalg_eigh(&self, uplo: &str) -> Result<(Tensor, Tensor), TchError>
pub fn f_linalg_eigh_eigvals(
&self,
eigvals: &Tensor,
eigvecs: &Tensor,
uplo: &str
) -> Result<(Tensor, Tensor), TchError>
pub fn f_linalg_eigvals(&self) -> Result<Tensor, TchError>
pub fn f_linalg_eigvals_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_linalg_eigvalsh(&self, uplo: &str) -> Result<Tensor, TchError>
pub fn f_linalg_eigvalsh_out(
&self,
out: &Tensor,
uplo: &str
) -> Result<Tensor, TchError>
pub fn f_linalg_householder_product(
&self,
tau: &Tensor
) -> Result<Tensor, TchError>
pub fn f_linalg_householder_product_out(
&self,
out: &Tensor,
tau: &Tensor
) -> Result<Tensor, TchError>
pub fn f_linalg_inv(&self) -> Result<Tensor, TchError>
pub fn f_linalg_inv_ex(
&self,
check_errors: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_linalg_inv_ex_inverse(
&self,
inverse: &Tensor,
info: &Tensor,
check_errors: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_linalg_inv_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_linalg_lstsq(
&self,
b: &Tensor,
rcond: impl Into<Option<f64>>,
driver: &str
) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>
pub fn f_linalg_lstsq_out(
&self,
solution: &Tensor,
residuals: &Tensor,
rank: &Tensor,
singular_values: &Tensor,
b: &Tensor,
rcond: impl Into<Option<f64>>,
driver: &str
) -> Result<(Tensor, Tensor, Tensor, Tensor), TchError>
pub fn f_linalg_lu_factor(
a: &Tensor,
pivot: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_linalg_lu_factor_ex(
a: &Tensor,
pivot: bool,
check_errors: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_linalg_lu_factor_ex_out(
lu: &Tensor,
pivots: &Tensor,
info: &Tensor,
a: &Tensor,
pivot: bool,
check_errors: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_linalg_lu_factor_out(
lu: &Tensor,
pivots: &Tensor,
a: &Tensor,
pivot: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_linalg_matmul(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_linalg_matmul_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_linalg_matrix_exp(&self) -> Result<Tensor, TchError>
pub fn f_linalg_matrix_power(&self, n: i64) -> Result<Tensor, TchError>
pub fn f_linalg_matrix_power_out(
&self,
out: &Tensor,
n: i64
) -> Result<Tensor, TchError>
pub fn f_linalg_matrix_rank(
&self,
tol: f64,
hermitian: bool
) -> Result<Tensor, TchError>
pub fn f_linalg_matrix_rank_atol_rtol_float(
&self,
atol: impl Into<Option<f64>>,
rtol: impl Into<Option<f64>>,
hermitian: bool
) -> Result<Tensor, TchError>
pub fn f_linalg_matrix_rank_atol_rtol_float_out(
&self,
out: &Tensor,
atol: impl Into<Option<f64>>,
rtol: impl Into<Option<f64>>,
hermitian: bool
) -> Result<Tensor, TchError>
pub fn f_linalg_matrix_rank_atol_rtol_tensor<T: Borrow<Tensor>>(
&self,
atol: Option<T>,
rtol: Option<T>,
hermitian: bool
) -> Result<Tensor, TchError>
pub fn f_linalg_matrix_rank_atol_rtol_tensor_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
atol: Option<T>,
rtol: Option<T>,
hermitian: bool
) -> Result<Tensor, TchError>
pub fn f_linalg_matrix_rank_out(
&self,
out: &Tensor,
tol: f64,
hermitian: bool
) -> Result<Tensor, TchError>
pub fn f_linalg_matrix_rank_out_tol_tensor(
&self,
out: &Tensor,
tol: &Tensor,
hermitian: bool
) -> Result<Tensor, TchError>
pub fn f_linalg_matrix_rank_tol_tensor(
&self,
tol: &Tensor,
hermitian: bool
) -> Result<Tensor, TchError>
pub fn f_linalg_multi_dot<T: Borrow<Tensor>>(
tensors: &[T]
) -> Result<Tensor, TchError>
pub fn f_linalg_multi_dot_out<T: Borrow<Tensor>>(
out: &Tensor,
tensors: &[T]
) -> Result<Tensor, TchError>
pub fn f_linalg_norm<'a, S: Into<Scalar>>(
&self,
ord: S,
dim: impl Into<Option<&'a [i64]>>,
keepdim: bool,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_linalg_norm_ord_str<'a>(
&self,
ord: &str,
dim: impl Into<Option<&'a [i64]>>,
keepdim: bool,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_linalg_norm_ord_str_out<'a>(
&self,
out: &Tensor,
ord: &str,
dim: impl Into<Option<&'a [i64]>>,
keepdim: bool,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_linalg_norm_out<'a, S: Into<Scalar>>(
&self,
out: &Tensor,
ord: S,
dim: impl Into<Option<&'a [i64]>>,
keepdim: bool,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_linalg_pinv(
&self,
rcond: f64,
hermitian: bool
) -> Result<Tensor, TchError>
pub fn f_linalg_pinv_atol_rtol_float(
&self,
atol: impl Into<Option<f64>>,
rtol: impl Into<Option<f64>>,
hermitian: bool
) -> Result<Tensor, TchError>
pub fn f_linalg_pinv_atol_rtol_float_out(
&self,
out: &Tensor,
atol: impl Into<Option<f64>>,
rtol: impl Into<Option<f64>>,
hermitian: bool
) -> Result<Tensor, TchError>
pub fn f_linalg_pinv_atol_rtol_tensor<T: Borrow<Tensor>>(
&self,
atol: Option<T>,
rtol: Option<T>,
hermitian: bool
) -> Result<Tensor, TchError>
pub fn f_linalg_pinv_atol_rtol_tensor_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
atol: Option<T>,
rtol: Option<T>,
hermitian: bool
) -> Result<Tensor, TchError>
pub fn f_linalg_pinv_out(
&self,
out: &Tensor,
rcond: f64,
hermitian: bool
) -> Result<Tensor, TchError>
pub fn f_linalg_pinv_out_rcond_tensor(
&self,
out: &Tensor,
rcond: &Tensor,
hermitian: bool
) -> Result<Tensor, TchError>
pub fn f_linalg_pinv_rcond_tensor(
&self,
rcond: &Tensor,
hermitian: bool
) -> Result<Tensor, TchError>
pub fn f_linalg_qr(&self, mode: &str) -> Result<(Tensor, Tensor), TchError>
pub fn f_linalg_qr_out(
&self,
q: &Tensor,
r: &Tensor,
mode: &str
) -> Result<(Tensor, Tensor), TchError>
pub fn f_linalg_slogdet(&self) -> Result<(Tensor, Tensor), TchError>
pub fn f_linalg_slogdet_out(
&self,
sign: &Tensor,
logabsdet: &Tensor
) -> Result<(Tensor, Tensor), TchError>
pub fn f_linalg_solve(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_linalg_solve_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_linalg_solve_triangular(
&self,
b: &Tensor,
upper: bool,
left: bool,
unitriangular: bool
) -> Result<Tensor, TchError>
pub fn f_linalg_solve_triangular_out(
&self,
out: &Tensor,
b: &Tensor,
upper: bool,
left: bool,
unitriangular: bool
) -> Result<Tensor, TchError>
pub fn f_linalg_svd(
a: &Tensor,
full_matrices: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_linalg_svd_u(
u: &Tensor,
s: &Tensor,
vh: &Tensor,
a: &Tensor,
full_matrices: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_linalg_svdvals(a: &Tensor) -> Result<Tensor, TchError>
pub fn f_linalg_svdvals_out(
out: &Tensor,
a: &Tensor
) -> Result<Tensor, TchError>
pub fn f_linalg_tensorinv(&self, ind: i64) -> Result<Tensor, TchError>
pub fn f_linalg_tensorinv_out(
&self,
out: &Tensor,
ind: i64
) -> Result<Tensor, TchError>
pub fn f_linalg_tensorsolve<'a>(
&self,
other: &Tensor,
dims: impl Into<Option<&'a [i64]>>
) -> Result<Tensor, TchError>
pub fn f_linalg_tensorsolve_out<'a>(
&self,
out: &Tensor,
other: &Tensor,
dims: impl Into<Option<&'a [i64]>>
) -> Result<Tensor, TchError>
pub fn f_linear<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>
) -> Result<Tensor, TchError>
pub fn f_linear_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
weight: &Tensor,
bias: Option<T>
) -> Result<Tensor, TchError>
pub fn f_linspace<S: Into<Scalar>>(
start: S,
end: S,
steps: i64,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_linspace_out<S: Into<Scalar>>(
out: &Tensor,
start: S,
end: S,
steps: i64
) -> Result<Tensor, TchError>
pub fn f_log(&self) -> Result<Tensor, TchError>
pub fn f_log10(&self) -> Result<Tensor, TchError>
pub fn f_log10_(&mut self) -> Result<Tensor, TchError>
pub fn f_log10_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_log1p(&self) -> Result<Tensor, TchError>
pub fn f_log1p_(&mut self) -> Result<Tensor, TchError>
pub fn f_log1p_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_log2(&self) -> Result<Tensor, TchError>
pub fn f_log2_(&mut self) -> Result<Tensor, TchError>
pub fn f_log2_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_log_(&mut self) -> Result<Tensor, TchError>
pub fn f_log_normal_(&mut self, mean: f64, std: f64) -> Result<Tensor, TchError>
pub fn f_log_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_log_sigmoid(&self) -> Result<Tensor, TchError>
pub fn f_log_sigmoid_backward(
&self,
grad_output: &Tensor,
buffer: &Tensor
) -> Result<Tensor, TchError>
pub fn f_log_sigmoid_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
buffer: &Tensor
) -> Result<Tensor, TchError>
pub fn f_log_sigmoid_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_log_softmax(&self, dim: i64, dtype: Kind) -> Result<Tensor, TchError>
pub fn f_logaddexp(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_logaddexp2(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_logaddexp2_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_logaddexp_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_logcumsumexp(&self, dim: i64) -> Result<Tensor, TchError>
pub fn f_logcumsumexp_out(
&self,
out: &Tensor,
dim: i64
) -> Result<Tensor, TchError>
pub fn f_logdet(&self) -> Result<Tensor, TchError>
pub fn f_logical_and(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_logical_and_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_logical_and_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_logical_not(&self) -> Result<Tensor, TchError>
pub fn f_logical_not_(&mut self) -> Result<Tensor, TchError>
pub fn f_logical_not_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_logical_or(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_logical_or_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_logical_or_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_logical_xor(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_logical_xor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_logical_xor_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_logit(&self, eps: impl Into<Option<f64>>) -> Result<Tensor, TchError>
pub fn f_logit_(
&mut self,
eps: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_logit_backward(
&self,
grad_output: &Tensor,
eps: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_logit_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
eps: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_logit_out(
&self,
out: &Tensor,
eps: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_logspace<S: Into<Scalar>>(
start: S,
end: S,
steps: i64,
base: f64,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_logspace_out<S: Into<Scalar>>(
out: &Tensor,
start: S,
end: S,
steps: i64,
base: f64
) -> Result<Tensor, TchError>
pub fn f_logsumexp(
&self,
dim: &[i64],
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_logsumexp_out(
&self,
out: &Tensor,
dim: &[i64],
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_lstm<T: Borrow<Tensor>>(
&self,
hx: &[T],
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool,
batch_first: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_lstm_cell<T: Borrow<Tensor>>(
&self,
hx: &[T],
w_ih: &Tensor,
w_hh: &Tensor,
b_ih: Option<T>,
b_hh: Option<T>
) -> Result<(Tensor, Tensor), TchError>
pub fn f_lstm_data<T: Borrow<Tensor>>(
data: &Tensor,
batch_sizes: &Tensor,
hx: &[T],
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_lstsq(&self, a: &Tensor) -> Result<(Tensor, Tensor), TchError>
pub fn f_lstsq_x(
&self,
x: &Tensor,
qr: &Tensor,
a: &Tensor
) -> Result<(Tensor, Tensor), TchError>
pub fn f_lt<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>
pub fn f_lt_<S: Into<Scalar>>(&mut self, other: S) -> Result<Tensor, TchError>
pub fn f_lt_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_lt_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_lt_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_lt_tensor_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_lu_solve(
&self,
lu_data: &Tensor,
lu_pivots: &Tensor
) -> Result<Tensor, TchError>
pub fn f_lu_solve_out(
&self,
out: &Tensor,
lu_data: &Tensor,
lu_pivots: &Tensor
) -> Result<Tensor, TchError>
pub fn f_lu_unpack(
lu_data: &Tensor,
lu_pivots: &Tensor,
unpack_data: bool,
unpack_pivots: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_lu_unpack_out(
p: &Tensor,
l: &Tensor,
u: &Tensor,
lu_data: &Tensor,
lu_pivots: &Tensor,
unpack_data: bool,
unpack_pivots: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_margin_ranking_loss(
input1: &Tensor,
input2: &Tensor,
target: &Tensor,
margin: f64,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_masked_fill<S: Into<Scalar>>(
&self,
mask: &Tensor,
value: S
) -> Result<Tensor, TchError>
pub fn f_masked_fill_<S: Into<Scalar>>(
&mut self,
mask: &Tensor,
value: S
) -> Result<Tensor, TchError>
pub fn f_masked_fill_tensor(
&self,
mask: &Tensor,
value: &Tensor
) -> Result<Tensor, TchError>
pub fn f_masked_fill_tensor_(
&mut self,
mask: &Tensor,
value: &Tensor
) -> Result<Tensor, TchError>
pub fn f_masked_scatter(
&self,
mask: &Tensor,
source: &Tensor
) -> Result<Tensor, TchError>
pub fn f_masked_scatter_(
&mut self,
mask: &Tensor,
source: &Tensor
) -> Result<Tensor, TchError>
pub fn f_masked_select(&self, mask: &Tensor) -> Result<Tensor, TchError>
pub fn f_masked_select_backward(
&self,
grad: &Tensor,
mask: &Tensor
) -> Result<Tensor, TchError>
pub fn f_masked_select_out(
&self,
out: &Tensor,
mask: &Tensor
) -> Result<Tensor, TchError>
pub fn f_matmul(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_matmul_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_matrix_exp(&self) -> Result<Tensor, TchError>
pub fn f_matrix_exp_backward(&self, grad: &Tensor) -> Result<Tensor, TchError>
pub fn f_matrix_h(&self) -> Result<Tensor, TchError>
pub fn f_matrix_power(&self, n: i64) -> Result<Tensor, TchError>
pub fn f_matrix_power_out(
&self,
out: &Tensor,
n: i64
) -> Result<Tensor, TchError>
pub fn f_matrix_rank(&self, symmetric: bool) -> Result<Tensor, TchError>
pub fn f_matrix_rank_tol(
&self,
tol: f64,
symmetric: bool
) -> Result<Tensor, TchError>
pub fn f_max(&self) -> Result<Tensor, TchError>
pub fn f_max_dim(
&self,
dim: i64,
keepdim: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_max_dim_max(
&self,
max: &Tensor,
max_values: &Tensor,
dim: i64,
keepdim: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_max_other(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_max_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_max_pool1d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Result<Tensor, TchError>
pub fn f_max_pool1d_with_indices(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_max_pool2d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Result<Tensor, TchError>
pub fn f_max_pool2d_with_indices(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_max_pool2d_with_indices_backward(
&self,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool,
indices: &Tensor
) -> Result<Tensor, TchError>
pub fn f_max_pool2d_with_indices_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool,
indices: &Tensor
) -> Result<Tensor, TchError>
pub fn f_max_pool2d_with_indices_out(
&self,
out: &Tensor,
indices: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_max_pool3d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Result<Tensor, TchError>
pub fn f_max_pool3d_with_indices(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_max_pool3d_with_indices_backward(
&self,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool,
indices: &Tensor
) -> Result<Tensor, TchError>
pub fn f_max_pool3d_with_indices_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool,
indices: &Tensor
) -> Result<Tensor, TchError>
pub fn f_max_pool3d_with_indices_out(
&self,
out: &Tensor,
indices: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_max_unpool2d(
&self,
indices: &Tensor,
output_size: &[i64]
) -> Result<Tensor, TchError>
pub fn f_max_unpool2d_backward(
&self,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Result<Tensor, TchError>
pub fn f_max_unpool2d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Result<Tensor, TchError>
pub fn f_max_unpool2d_out(
&self,
out: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Result<Tensor, TchError>
pub fn f_max_unpool3d(
&self,
indices: &Tensor,
output_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_max_unpool3d_backward(
&self,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_max_unpool3d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_max_unpool3d_out(
&self,
out: &Tensor,
indices: &Tensor,
output_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_maximum(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_maximum_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_mean(&self, dtype: Kind) -> Result<Tensor, TchError>
pub fn f_mean_dim(
&self,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_mean_out(
&self,
out: &Tensor,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_median(&self) -> Result<Tensor, TchError>
pub fn f_median_dim(
&self,
dim: i64,
keepdim: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_median_dim_values(
&self,
values: &Tensor,
indices: &Tensor,
dim: i64,
keepdim: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_meshgrid<T: Borrow<Tensor>>(
tensors: &[T]
) -> Result<Vec<Tensor>, TchError>
pub fn f_meshgrid_indexing<T: Borrow<Tensor>>(
tensors: &[T],
indexing: &str
) -> Result<Vec<Tensor>, TchError>
pub fn f_mh(&self) -> Result<Tensor, TchError>
pub fn f_min(&self) -> Result<Tensor, TchError>
pub fn f_min_dim(
&self,
dim: i64,
keepdim: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_min_dim_min(
&self,
min: &Tensor,
min_indices: &Tensor,
dim: i64,
keepdim: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_min_other(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_min_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_minimum(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_minimum_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_miopen_batch_norm<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
running_mean: Option<T>,
running_var: Option<T>,
training: bool,
exponential_average_factor: f64,
epsilon: f64
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_miopen_batch_norm_backward<T: Borrow<Tensor>>(
&self,
grad_output: &Tensor,
weight: &Tensor,
running_mean: Option<T>,
running_var: Option<T>,
save_mean: Option<T>,
save_var: Option<T>,
epsilon: f64
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_miopen_convolution<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Result<Tensor, TchError>
pub fn f_miopen_convolution_transpose<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
output_padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Result<Tensor, TchError>
pub fn f_miopen_depthwise_convolution<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Result<Tensor, TchError>
pub fn f_miopen_rnn<T: Borrow<Tensor>>(
&self,
weight: &[T],
weight_stride0: i64,
hx: &Tensor,
cx: Option<T>,
mode: i64,
hidden_size: i64,
num_layers: i64,
batch_first: bool,
dropout: f64,
train: bool,
bidirectional: bool,
batch_sizes: &[i64],
dropout_state: Option<T>
) -> Result<(Tensor, Tensor, Tensor, Tensor, Tensor), TchError>
pub fn f_mish(&self) -> Result<Tensor, TchError>
pub fn f_mish_(&mut self) -> Result<Tensor, TchError>
pub fn f_mish_backward(&self, grad_output: &Tensor) -> Result<Tensor, TchError>
pub fn f_mish_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_mkldnn_adaptive_avg_pool2d(
&self,
output_size: &[i64]
) -> Result<Tensor, TchError>
pub fn f_mkldnn_adaptive_avg_pool2d_backward(
&self,
grad_output: &Tensor
) -> Result<Tensor, TchError>
pub fn f_mkldnn_convolution<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64
) -> Result<Tensor, TchError>
pub fn f_mkldnn_linear<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>
) -> Result<Tensor, TchError>
pub fn f_mkldnn_linear_backward_input(
input_size: &[i64],
grad_output: &Tensor,
weight: &Tensor
) -> Result<Tensor, TchError>
pub fn f_mkldnn_linear_backward_weights(
&self,
grad_output: &Tensor,
weight: &Tensor,
bias_defined: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_mkldnn_max_pool2d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Result<Tensor, TchError>
pub fn f_mkldnn_max_pool2d_backward(
&self,
grad_output: &Tensor,
output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Result<Tensor, TchError>
pub fn f_mkldnn_max_pool3d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Result<Tensor, TchError>
pub fn f_mkldnn_max_pool3d_backward(
&self,
grad_output: &Tensor,
output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Result<Tensor, TchError>
pub fn f_mkldnn_reorder_conv2d_weight(
&self,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64
) -> Result<Tensor, TchError>
pub fn f_mkldnn_reorder_conv3d_weight(
&self,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64
) -> Result<Tensor, TchError>
pub fn f_mm(&self, mat2: &Tensor) -> Result<Tensor, TchError>
pub fn f_mm_out(&self, out: &Tensor, mat2: &Tensor) -> Result<Tensor, TchError>
pub fn f_mode(
&self,
dim: i64,
keepdim: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_mode_values(
&self,
values: &Tensor,
indices: &Tensor,
dim: i64,
keepdim: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_moveaxis(
&self,
source: &[i64],
destination: &[i64]
) -> Result<Tensor, TchError>
pub fn f_moveaxis_int(
&self,
source: i64,
destination: i64
) -> Result<Tensor, TchError>
pub fn f_movedim(
&self,
source: &[i64],
destination: &[i64]
) -> Result<Tensor, TchError>
pub fn f_movedim_int(
&self,
source: i64,
destination: i64
) -> Result<Tensor, TchError>
pub fn f_mse_loss(
&self,
target: &Tensor,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_mse_loss_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_mse_loss_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_mse_loss_out(
&self,
out: &Tensor,
target: &Tensor,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_msort(&self) -> Result<Tensor, TchError>
pub fn f_msort_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_mt(&self) -> Result<Tensor, TchError>
pub fn f_mul(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_mul_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_mul_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_mul_scalar<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_mul_scalar_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_multi_margin_loss_backward<T: Borrow<Tensor>, S: Into<Scalar>>(
&self,
grad_output: &Tensor,
target: &Tensor,
p: S,
margin: S,
weight: Option<T>,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_multi_margin_loss_backward_grad_input<T: Borrow<Tensor>, S: Into<Scalar>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
p: S,
margin: S,
weight: Option<T>,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_multilabel_margin_loss(
&self,
target: &Tensor,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_multilabel_margin_loss_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction,
is_target: &Tensor
) -> Result<Tensor, TchError>
pub fn f_multilabel_margin_loss_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction,
is_target: &Tensor
) -> Result<Tensor, TchError>
pub fn f_multilabel_margin_loss_out(
&self,
out: &Tensor,
target: &Tensor,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_multinomial(
&self,
num_samples: i64,
replacement: bool
) -> Result<Tensor, TchError>
pub fn f_multinomial_out(
&self,
out: &Tensor,
num_samples: i64,
replacement: bool
) -> Result<Tensor, TchError>
pub fn f_multiply(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_multiply_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_multiply_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_multiply_scalar<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_multiply_scalar_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_mv(&self, vec: &Tensor) -> Result<Tensor, TchError>
pub fn f_mv_out(&self, out: &Tensor, vec: &Tensor) -> Result<Tensor, TchError>
pub fn f_mvlgamma(&self, p: i64) -> Result<Tensor, TchError>
pub fn f_mvlgamma_(&mut self, p: i64) -> Result<Tensor, TchError>
pub fn f_mvlgamma_out(&self, out: &Tensor, p: i64) -> Result<Tensor, TchError>
pub fn f_nan_to_num(
&self,
nan: impl Into<Option<f64>>,
posinf: impl Into<Option<f64>>,
neginf: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_nan_to_num_(
&mut self,
nan: impl Into<Option<f64>>,
posinf: impl Into<Option<f64>>,
neginf: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_nan_to_num_out(
&self,
out: &Tensor,
nan: impl Into<Option<f64>>,
posinf: impl Into<Option<f64>>,
neginf: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_nanmean(
&self,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_nanmean_out(
&self,
out: &Tensor,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_nanmedian(&self) -> Result<Tensor, TchError>
pub fn f_nanmedian_dim(
&self,
dim: i64,
keepdim: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_nanmedian_dim_values(
&self,
values: &Tensor,
indices: &Tensor,
dim: i64,
keepdim: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_nanquantile(
&self,
q: &Tensor,
dim: impl Into<Option<i64>>,
keepdim: bool,
interpolation: &str
) -> Result<Tensor, TchError>
pub fn f_nanquantile_out(
&self,
out: &Tensor,
q: &Tensor,
dim: impl Into<Option<i64>>,
keepdim: bool,
interpolation: &str
) -> Result<Tensor, TchError>
pub fn f_nanquantile_scalar(
&self,
q: f64,
dim: impl Into<Option<i64>>,
keepdim: bool,
interpolation: &str
) -> Result<Tensor, TchError>
pub fn f_nanquantile_scalar_out(
&self,
out: &Tensor,
q: f64,
dim: impl Into<Option<i64>>,
keepdim: bool,
interpolation: &str
) -> Result<Tensor, TchError>
pub fn f_nansum(&self, dtype: Kind) -> Result<Tensor, TchError>
pub fn f_nansum_dim_intlist(
&self,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_nansum_intlist_out(
&self,
out: &Tensor,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_narrow(
&self,
dim: i64,
start: i64,
length: i64
) -> Result<Tensor, TchError>
pub fn f_narrow_copy(
&self,
dim: i64,
start: i64,
length: i64
) -> Result<Tensor, TchError>
pub fn f_narrow_copy_out(
&self,
out: &Tensor,
dim: i64,
start: i64,
length: i64
) -> Result<Tensor, TchError>
pub fn f_narrow_tensor(
&self,
dim: i64,
start: &Tensor,
length: i64
) -> Result<Tensor, TchError>
pub fn f_native_batch_norm<T: Borrow<Tensor>>(
&self,
weight: Option<T>,
bias: Option<T>,
running_mean: Option<T>,
running_var: Option<T>,
training: bool,
momentum: f64,
eps: f64
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_native_batch_norm_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
save_mean: &Tensor,
save_invstd: &Tensor,
weight: Option<T>,
bias: Option<T>,
running_mean: Option<T>,
running_var: Option<T>,
training: bool,
momentum: f64,
eps: f64
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_native_channel_shuffle(&self, groups: i64) -> Result<Tensor, TchError>
pub fn f_native_dropout(
&self,
p: f64,
train: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_native_dropout_backward(
grad_output: &Tensor,
mask: &Tensor,
scale: f64
) -> Result<Tensor, TchError>
pub fn f_native_group_norm<T: Borrow<Tensor>>(
&self,
weight: Option<T>,
bias: Option<T>,
n: i64,
c: i64,
hxw: i64,
group: i64,
eps: f64
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_native_layer_norm<T: Borrow<Tensor>>(
&self,
normalized_shape: &[i64],
weight: Option<T>,
bias: Option<T>,
eps: f64
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_native_norm(&self) -> Result<Tensor, TchError>
pub fn f_native_norm_scalaropt_dim_dtype<S: Into<Scalar>>(
&self,
p: S,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_ne<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>
pub fn f_ne_<S: Into<Scalar>>(&mut self, other: S) -> Result<Tensor, TchError>
pub fn f_ne_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_ne_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_ne_tensor_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_ne_tensor_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_neg(&self) -> Result<Tensor, TchError>
pub fn f_neg_(&mut self) -> Result<Tensor, TchError>
pub fn f_neg_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_negative(&self) -> Result<Tensor, TchError>
pub fn f_negative_(&mut self) -> Result<Tensor, TchError>
pub fn f_negative_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_new_empty(
&self,
size: &[i64],
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_new_empty_strided(
&self,
size: &[i64],
stride: &[i64],
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_new_full<S: Into<Scalar>>(
&self,
size: &[i64],
fill_value: S,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_new_ones(
&self,
size: &[i64],
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_new_zeros(
&self,
size: &[i64],
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_nextafter(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_nextafter_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_nextafter_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_nll_loss<T: Borrow<Tensor>>(
&self,
target: &Tensor,
weight: Option<T>,
reduction: Reduction,
ignore_index: i64
) -> Result<Tensor, TchError>
pub fn f_nll_loss2d<T: Borrow<Tensor>>(
&self,
target: &Tensor,
weight: Option<T>,
reduction: Reduction,
ignore_index: i64
) -> Result<Tensor, TchError>
pub fn f_nll_loss2d_backward<T: Borrow<Tensor>>(
&self,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: Reduction,
ignore_index: i64,
total_weight: &Tensor
) -> Result<Tensor, TchError>
pub fn f_nll_loss2d_backward_grad_input<T: Borrow<Tensor>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: Reduction,
ignore_index: i64,
total_weight: &Tensor
) -> Result<Tensor, TchError>
pub fn f_nll_loss2d_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: Reduction,
ignore_index: i64
) -> Result<Tensor, TchError>
pub fn f_nll_loss_backward<T: Borrow<Tensor>>(
&self,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: Reduction,
ignore_index: i64,
total_weight: &Tensor
) -> Result<Tensor, TchError>
pub fn f_nll_loss_backward_grad_input<T: Borrow<Tensor>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: Reduction,
ignore_index: i64,
total_weight: &Tensor
) -> Result<Tensor, TchError>
pub fn f_nll_loss_nd<T: Borrow<Tensor>>(
&self,
target: &Tensor,
weight: Option<T>,
reduction: Reduction,
ignore_index: i64
) -> Result<Tensor, TchError>
pub fn f_nll_loss_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: Reduction,
ignore_index: i64
) -> Result<Tensor, TchError>
pub fn f_nonzero(&self) -> Result<Tensor, TchError>
pub fn f_nonzero_numpy(&self) -> Result<Vec<Tensor>, TchError>
pub fn f_nonzero_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_norm(&self) -> Result<Tensor, TchError>
pub fn f_norm_dtype_out<S: Into<Scalar>>(
&self,
out: &Tensor,
p: S,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_norm_except_dim(
v: &Tensor,
pow: i64,
dim: i64
) -> Result<Tensor, TchError>
pub fn f_norm_out<S: Into<Scalar>>(
&self,
out: &Tensor,
p: S,
dim: &[i64],
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_norm_scalaropt_dim<S: Into<Scalar>>(
&self,
p: S,
dim: &[i64],
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_norm_scalaropt_dim_dtype<S: Into<Scalar>>(
&self,
p: S,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_norm_scalaropt_dtype<S: Into<Scalar>>(
&self,
p: S,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_normal(
out: &Tensor,
mean: &Tensor,
std: f64
) -> Result<Tensor, TchError>
pub fn f_normal_(&mut self, mean: f64, std: f64) -> Result<Tensor, TchError>
pub fn f_normal_float_float_out(
out: &Tensor,
mean: f64,
std: f64,
size: &[i64]
) -> Result<Tensor, TchError>
pub fn f_normal_float_tensor_out(
out: &Tensor,
mean: f64,
std: &Tensor
) -> Result<Tensor, TchError>
pub fn f_normal_tensor_tensor_out(
out: &Tensor,
mean: &Tensor,
std: &Tensor
) -> Result<Tensor, TchError>
pub fn f_not_equal<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>
pub fn f_not_equal_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_not_equal_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_not_equal_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_not_equal_tensor_(
&mut self,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_not_equal_tensor_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_nuclear_norm(&self, keepdim: bool) -> Result<Tensor, TchError>
pub fn f_nuclear_norm_dim(
&self,
dim: &[i64],
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_nuclear_norm_dim_out(
&self,
out: &Tensor,
dim: &[i64],
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_nuclear_norm_out(
&self,
out: &Tensor,
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_numpy_t(&self) -> Result<Tensor, TchError>
pub fn f_one_hot(&self, num_classes: i64) -> Result<Tensor, TchError>
pub fn f_ones(size: &[i64], options: (Kind, Device)) -> Result<Tensor, TchError>
pub fn f_ones_like(&self) -> Result<Tensor, TchError>
pub fn f_ones_out(out: &Tensor, size: &[i64]) -> Result<Tensor, TchError>
pub fn f_orgqr(&self, input2: &Tensor) -> Result<Tensor, TchError>
pub fn f_orgqr_out(
&self,
out: &Tensor,
input2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_ormqr(
&self,
input2: &Tensor,
input3: &Tensor,
left: bool,
transpose: bool
) -> Result<Tensor, TchError>
pub fn f_ormqr_out(
&self,
out: &Tensor,
input2: &Tensor,
input3: &Tensor,
left: bool,
transpose: bool
) -> Result<Tensor, TchError>
pub fn f_outer(&self, vec2: &Tensor) -> Result<Tensor, TchError>
pub fn f_outer_out(
&self,
out: &Tensor,
vec2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_output_nr(&self) -> Result<i64, TchError>
pub fn f_pad_sequence<T: Borrow<Tensor>>(
sequences: &[T],
batch_first: bool,
padding_value: f64
) -> Result<Tensor, TchError>
pub fn f_pairwise_distance(
x1: &Tensor,
x2: &Tensor,
p: f64,
eps: f64,
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_pdist(&self, p: f64) -> Result<Tensor, TchError>
pub fn f_permute(&self, dims: &[i64]) -> Result<Tensor, TchError>
pub fn f_pin_memory(&self, device: Device) -> Result<Tensor, TchError>
pub fn f_pinverse(&self, rcond: f64) -> Result<Tensor, TchError>
pub fn f_pixel_shuffle(&self, upscale_factor: i64) -> Result<Tensor, TchError>
pub fn f_pixel_unshuffle(
&self,
downscale_factor: i64
) -> Result<Tensor, TchError>
pub fn f_poisson(&self) -> Result<Tensor, TchError>
pub fn f_poisson_nll_loss(
&self,
target: &Tensor,
log_input: bool,
full: bool,
eps: f64,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_polar(abs: &Tensor, angle: &Tensor) -> Result<Tensor, TchError>
pub fn f_polar_out(
out: &Tensor,
abs: &Tensor,
angle: &Tensor
) -> Result<Tensor, TchError>
pub fn f_polygamma(&self, n: i64) -> Result<Tensor, TchError>
pub fn f_polygamma_(&mut self, n: i64) -> Result<Tensor, TchError>
pub fn f_polygamma_out(&self, out: &Tensor, n: i64) -> Result<Tensor, TchError>
pub fn f_positive(&self) -> Result<Tensor, TchError>
pub fn f_pow(&self, exponent: &Tensor) -> Result<Tensor, TchError>
pub fn f_pow_<S: Into<Scalar>>(
&mut self,
exponent: S
) -> Result<Tensor, TchError>
pub fn f_pow_scalar<S: Into<Scalar>>(
self_scalar: S,
exponent: &Tensor
) -> Result<Tensor, TchError>
pub fn f_pow_scalar_out<S: Into<Scalar>>(
out: &Tensor,
self_scalar: S,
exponent: &Tensor
) -> Result<Tensor, TchError>
pub fn f_pow_tensor_(&mut self, exponent: &Tensor) -> Result<Tensor, TchError>
pub fn f_pow_tensor_scalar<S: Into<Scalar>>(
&self,
exponent: S
) -> Result<Tensor, TchError>
pub fn f_pow_tensor_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
exponent: S
) -> Result<Tensor, TchError>
pub fn f_pow_tensor_tensor_out(
&self,
out: &Tensor,
exponent: &Tensor
) -> Result<Tensor, TchError>
pub fn f_prelu(&self, weight: &Tensor) -> Result<Tensor, TchError>
pub fn f_prelu_backward(
&self,
grad_output: &Tensor,
weight: &Tensor
) -> Result<(Tensor, Tensor), TchError>
pub fn f_prod(&self, dtype: Kind) -> Result<Tensor, TchError>
pub fn f_prod_dim_int(
&self,
dim: i64,
keepdim: bool,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_prod_int_out(
&self,
out: &Tensor,
dim: i64,
keepdim: bool,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_put(
&self,
index: &Tensor,
source: &Tensor,
accumulate: bool
) -> Result<Tensor, TchError>
pub fn f_put_(
&mut self,
index: &Tensor,
source: &Tensor,
accumulate: bool
) -> Result<Tensor, TchError>
pub fn f_q_per_channel_axis(&self) -> Result<i64, TchError>
pub fn f_q_per_channel_scales(&self) -> Result<Tensor, TchError>
pub fn f_q_per_channel_zero_points(&self) -> Result<Tensor, TchError>
pub fn f_q_scale(&self) -> Result<f64, TchError>
pub fn f_q_zero_point(&self) -> Result<i64, TchError>
pub fn f_qr(&self, some: bool) -> Result<(Tensor, Tensor), TchError>
pub fn f_qr_q(
&self,
q: &Tensor,
r: &Tensor,
some: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_quantile(
&self,
q: &Tensor,
dim: impl Into<Option<i64>>,
keepdim: bool,
interpolation: &str
) -> Result<Tensor, TchError>
pub fn f_quantile_out(
&self,
out: &Tensor,
q: &Tensor,
dim: impl Into<Option<i64>>,
keepdim: bool,
interpolation: &str
) -> Result<Tensor, TchError>
pub fn f_quantile_scalar(
&self,
q: f64,
dim: impl Into<Option<i64>>,
keepdim: bool,
interpolation: &str
) -> Result<Tensor, TchError>
pub fn f_quantile_scalar_out(
&self,
out: &Tensor,
q: f64,
dim: impl Into<Option<i64>>,
keepdim: bool,
interpolation: &str
) -> Result<Tensor, TchError>
pub fn f_quantize_per_channel(
&self,
scales: &Tensor,
zero_points: &Tensor,
axis: i64,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_quantize_per_tensor(
&self,
scale: f64,
zero_point: i64,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_quantize_per_tensor_dynamic(
&self,
dtype: Kind,
reduce_range: bool
) -> Result<Tensor, TchError>
pub fn f_quantize_per_tensor_tensor_qparams(
&self,
scale: &Tensor,
zero_point: &Tensor,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_quantize_per_tensor_tensors<T: Borrow<Tensor>>(
tensors: &[T],
scales: &Tensor,
zero_points: &Tensor,
dtype: Kind
) -> Result<Vec<Tensor>, TchError>
pub fn f_quantized_batch_norm<T: Borrow<Tensor>>(
&self,
weight: Option<T>,
bias: Option<T>,
mean: &Tensor,
var: &Tensor,
eps: f64,
output_scale: f64,
output_zero_point: i64
) -> Result<Tensor, TchError>
pub fn f_quantized_gru_cell<S: Into<Scalar>>(
&self,
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: S,
scale_hh: S,
zero_point_ih: S,
zero_point_hh: S
) -> Result<Tensor, TchError>
pub fn f_quantized_lstm_cell<T: Borrow<Tensor>, S: Into<Scalar>>(
&self,
hx: &[T],
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: S,
scale_hh: S,
zero_point_ih: S,
zero_point_hh: S
) -> Result<(Tensor, Tensor), TchError>
pub fn f_quantized_max_pool1d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Result<Tensor, TchError>
pub fn f_quantized_max_pool2d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Result<Tensor, TchError>
pub fn f_quantized_rnn_relu_cell<S: Into<Scalar>>(
&self,
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: S,
scale_hh: S,
zero_point_ih: S,
zero_point_hh: S
) -> Result<Tensor, TchError>
pub fn f_quantized_rnn_tanh_cell<S: Into<Scalar>>(
&self,
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: S,
scale_hh: S,
zero_point_ih: S,
zero_point_hh: S
) -> Result<Tensor, TchError>
pub fn f_rad2deg(&self) -> Result<Tensor, TchError>
pub fn f_rad2deg_(&mut self) -> Result<Tensor, TchError>
pub fn f_rad2deg_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_rand(size: &[i64], options: (Kind, Device)) -> Result<Tensor, TchError>
pub fn f_rand_like(&self) -> Result<Tensor, TchError>
pub fn f_rand_out(out: &Tensor, size: &[i64]) -> Result<Tensor, TchError>
pub fn f_randint(
high: i64,
size: &[i64],
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_randint_like(&self, high: i64) -> Result<Tensor, TchError>
pub fn f_randint_like_low_dtype(
&self,
low: i64,
high: i64
) -> Result<Tensor, TchError>
pub fn f_randint_low(
low: i64,
high: i64,
size: &[i64],
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_randint_low_out(
out: &Tensor,
low: i64,
high: i64,
size: &[i64]
) -> Result<Tensor, TchError>
pub fn f_randint_out(
out: &Tensor,
high: i64,
size: &[i64]
) -> Result<Tensor, TchError>
pub fn f_randn(
size: &[i64],
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_randn_like(&self) -> Result<Tensor, TchError>
pub fn f_randn_out(out: &Tensor, size: &[i64]) -> Result<Tensor, TchError>
pub fn f_random_(&mut self) -> Result<Tensor, TchError>
pub fn f_random_from_(
&mut self,
from: i64,
to: impl Into<Option<i64>>
) -> Result<Tensor, TchError>
pub fn f_random_to_(&mut self, to: i64) -> Result<Tensor, TchError>
pub fn f_randperm(n: i64, options: (Kind, Device)) -> Result<Tensor, TchError>
pub fn f_randperm_out(out: &Tensor, n: i64) -> Result<Tensor, TchError>
pub fn f_range<S: Into<Scalar>>(
start: S,
end: S,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_range_out<S: Into<Scalar>>(
out: &Tensor,
start: S,
end: S
) -> Result<Tensor, TchError>
pub fn f_range_step<S: Into<Scalar>>(
start: S,
end: S,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_ravel(&self) -> Result<Tensor, TchError>
pub fn f_real(&self) -> Result<Tensor, TchError>
pub fn f_reciprocal(&self) -> Result<Tensor, TchError>
pub fn f_reciprocal_(&mut self) -> Result<Tensor, TchError>
pub fn f_reciprocal_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_reflection_pad1d(&self, padding: &[i64]) -> Result<Tensor, TchError>
pub fn f_reflection_pad1d_backward(
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_reflection_pad1d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_reflection_pad1d_out(
&self,
out: &Tensor,
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_reflection_pad2d(&self, padding: &[i64]) -> Result<Tensor, TchError>
pub fn f_reflection_pad2d_backward(
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_reflection_pad2d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_reflection_pad2d_out(
&self,
out: &Tensor,
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_reflection_pad3d(&self, padding: &[i64]) -> Result<Tensor, TchError>
pub fn f_reflection_pad3d_backward(
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_reflection_pad3d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_reflection_pad3d_out(
&self,
out: &Tensor,
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_relu(&self) -> Result<Tensor, TchError>
pub fn f_relu6(&self) -> Result<Tensor, TchError>
pub fn f_relu6_(&mut self) -> Result<Tensor, TchError>
pub fn f_relu_(&mut self) -> Result<Tensor, TchError>
pub fn f_remainder<S: Into<Scalar>>(&self, other: S) -> Result<Tensor, TchError>
pub fn f_remainder_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_remainder_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_remainder_scalar_tensor<S: Into<Scalar>>(
self_scalar: S,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_remainder_tensor(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_remainder_tensor_(
&mut self,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_remainder_tensor_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_renorm<S: Into<Scalar>>(
&self,
p: S,
dim: i64,
maxnorm: S
) -> Result<Tensor, TchError>
pub fn f_renorm_<S: Into<Scalar>>(
&mut self,
p: S,
dim: i64,
maxnorm: S
) -> Result<Tensor, TchError>
pub fn f_renorm_out<S: Into<Scalar>>(
&self,
out: &Tensor,
p: S,
dim: i64,
maxnorm: S
) -> Result<Tensor, TchError>
pub fn f_repeat(&self, repeats: &[i64]) -> Result<Tensor, TchError>
pub fn f_repeat_interleave(
repeats: &Tensor,
output_size: impl Into<Option<i64>>
) -> Result<Tensor, TchError>
pub fn f_repeat_interleave_self_int(
&self,
repeats: i64,
dim: impl Into<Option<i64>>,
output_size: impl Into<Option<i64>>
) -> Result<Tensor, TchError>
pub fn f_repeat_interleave_self_tensor(
&self,
repeats: &Tensor,
dim: impl Into<Option<i64>>,
output_size: impl Into<Option<i64>>
) -> Result<Tensor, TchError>
pub fn f_replication_pad1d(&self, padding: &[i64]) -> Result<Tensor, TchError>
pub fn f_replication_pad1d_backward(
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_replication_pad1d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_replication_pad1d_out(
&self,
out: &Tensor,
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_replication_pad2d(&self, padding: &[i64]) -> Result<Tensor, TchError>
pub fn f_replication_pad2d_backward(
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_replication_pad2d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_replication_pad2d_out(
&self,
out: &Tensor,
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_replication_pad3d(&self, padding: &[i64]) -> Result<Tensor, TchError>
pub fn f_replication_pad3d_backward(
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_replication_pad3d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_replication_pad3d_out(
&self,
out: &Tensor,
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_requires_grad_(
&mut self,
requires_grad: bool
) -> Result<Tensor, TchError>
pub fn f_reshape(&self, shape: &[i64]) -> Result<Tensor, TchError>
pub fn f_reshape_as(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_resize_(&mut self, size: &[i64]) -> Result<Tensor, TchError>
pub fn f_resize_as_(
&mut self,
the_template: &Tensor
) -> Result<Tensor, TchError>
pub fn f_resize_as_sparse_(
&mut self,
the_template: &Tensor
) -> Result<Tensor, TchError>
pub fn f_resolve_conj(&self) -> Result<Tensor, TchError>
pub fn f_resolve_neg(&self) -> Result<Tensor, TchError>
pub fn f_retains_grad(&self) -> Result<bool, TchError>
pub fn f_rnn_relu<T: Borrow<Tensor>>(
&self,
hx: &Tensor,
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool,
batch_first: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_rnn_relu_cell<T: Borrow<Tensor>>(
&self,
hx: &Tensor,
w_ih: &Tensor,
w_hh: &Tensor,
b_ih: Option<T>,
b_hh: Option<T>
) -> Result<Tensor, TchError>
pub fn f_rnn_relu_data<T: Borrow<Tensor>>(
data: &Tensor,
batch_sizes: &Tensor,
hx: &Tensor,
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_rnn_tanh<T: Borrow<Tensor>>(
&self,
hx: &Tensor,
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool,
batch_first: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_rnn_tanh_cell<T: Borrow<Tensor>>(
&self,
hx: &Tensor,
w_ih: &Tensor,
w_hh: &Tensor,
b_ih: Option<T>,
b_hh: Option<T>
) -> Result<Tensor, TchError>
pub fn f_rnn_tanh_data<T: Borrow<Tensor>>(
data: &Tensor,
batch_sizes: &Tensor,
hx: &Tensor,
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_roll(&self, shifts: &[i64], dims: &[i64]) -> Result<Tensor, TchError>
pub fn f_rot90(&self, k: i64, dims: &[i64]) -> Result<Tensor, TchError>
pub fn f_round(&self) -> Result<Tensor, TchError>
pub fn f_round_(&mut self) -> Result<Tensor, TchError>
pub fn f_round_decimals(&self, decimals: i64) -> Result<Tensor, TchError>
pub fn f_round_decimals_(&mut self, decimals: i64) -> Result<Tensor, TchError>
pub fn f_round_decimals_out(
&self,
out: &Tensor,
decimals: i64
) -> Result<Tensor, TchError>
pub fn f_round_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_row_stack<T: Borrow<Tensor>>(tensors: &[T]) -> Result<Tensor, TchError>
pub fn f_row_stack_out<T: Borrow<Tensor>>(
out: &Tensor,
tensors: &[T]
) -> Result<Tensor, TchError>
pub fn f_rrelu(&self, training: bool) -> Result<Tensor, TchError>
pub fn f_rrelu_(&mut self, training: bool) -> Result<Tensor, TchError>
pub fn f_rrelu_with_noise(
&self,
noise: &Tensor,
training: bool
) -> Result<Tensor, TchError>
pub fn f_rrelu_with_noise_(
&mut self,
noise: &Tensor,
training: bool
) -> Result<Tensor, TchError>
pub fn f_rrelu_with_noise_backward<S: Into<Scalar>>(
&self,
grad_output: &Tensor,
noise: &Tensor,
lower: S,
upper: S,
training: bool,
self_is_result: bool
) -> Result<Tensor, TchError>
pub fn f_rrelu_with_noise_out(
&self,
out: &Tensor,
noise: &Tensor,
training: bool
) -> Result<Tensor, TchError>
pub fn f_rsqrt(&self) -> Result<Tensor, TchError>
pub fn f_rsqrt_(&mut self) -> Result<Tensor, TchError>
pub fn f_rsqrt_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_rsub(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_rsub_scalar<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_scalar_tensor<S: Into<Scalar>>(
s: S,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_scatter(
&self,
dim: i64,
index: &Tensor,
src: &Tensor
) -> Result<Tensor, TchError>
pub fn f_scatter_(
&mut self,
dim: i64,
index: &Tensor,
src: &Tensor
) -> Result<Tensor, TchError>
pub fn f_scatter_add(
&self,
dim: i64,
index: &Tensor,
src: &Tensor
) -> Result<Tensor, TchError>
pub fn f_scatter_add_(
&mut self,
dim: i64,
index: &Tensor,
src: &Tensor
) -> Result<Tensor, TchError>
pub fn f_scatter_add_out(
&self,
out: &Tensor,
dim: i64,
index: &Tensor,
src: &Tensor
) -> Result<Tensor, TchError>
pub fn f_scatter_reduce(
&self,
dim: i64,
index: &Tensor,
src: &Tensor,
reduce: &str
) -> Result<Tensor, TchError>
pub fn f_scatter_reduce_(
&mut self,
dim: i64,
index: &Tensor,
src: &Tensor,
reduce: &str
) -> Result<Tensor, TchError>
pub fn f_scatter_reduce_out(
&self,
out: &Tensor,
dim: i64,
index: &Tensor,
src: &Tensor,
reduce: &str
) -> Result<Tensor, TchError>
pub fn f_scatter_src_out(
&self,
out: &Tensor,
dim: i64,
index: &Tensor,
src: &Tensor
) -> Result<Tensor, TchError>
pub fn f_scatter_value<S: Into<Scalar>>(
&self,
dim: i64,
index: &Tensor,
value: S
) -> Result<Tensor, TchError>
pub fn f_scatter_value_<S: Into<Scalar>>(
&mut self,
dim: i64,
index: &Tensor,
value: S
) -> Result<Tensor, TchError>
pub fn f_scatter_value_out<S: Into<Scalar>>(
&self,
out: &Tensor,
dim: i64,
index: &Tensor,
value: S
) -> Result<Tensor, TchError>
pub fn f_scatter_value_reduce<S: Into<Scalar>>(
&self,
dim: i64,
index: &Tensor,
value: S,
reduce: &str
) -> Result<Tensor, TchError>
pub fn f_scatter_value_reduce_<S: Into<Scalar>>(
&mut self,
dim: i64,
index: &Tensor,
value: S,
reduce: &str
) -> Result<Tensor, TchError>
pub fn f_scatter_value_reduce_out<S: Into<Scalar>>(
&self,
out: &Tensor,
dim: i64,
index: &Tensor,
value: S,
reduce: &str
) -> Result<Tensor, TchError>
pub fn f_searchsorted<T: Borrow<Tensor>>(
&self,
sorted_sequence: &Tensor,
out_int32: bool,
right: bool,
side: &str,
sorter: Option<T>
) -> Result<Tensor, TchError>
pub fn f_searchsorted_scalar<T: Borrow<Tensor>, S: Into<Scalar>>(
sorted_sequence: &Tensor,
self_scalar: S,
out_int32: bool,
right: bool,
side: &str,
sorter: Option<T>
) -> Result<Tensor, TchError>
pub fn f_searchsorted_tensor_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
sorted_sequence: &Tensor,
out_int32: bool,
right: bool,
side: &str,
sorter: Option<T>
) -> Result<Tensor, TchError>
pub fn f_segment_reduce<T: Borrow<Tensor>, S: Into<Scalar>>(
data: &Tensor,
reduce: &str,
lengths: Option<T>,
indices: Option<T>,
axis: i64,
unsafe_: bool,
initial: S
) -> Result<Tensor, TchError>
pub fn f_select(&self, dim: i64, index: i64) -> Result<Tensor, TchError>
pub fn f_select_backward(
grad_output: &Tensor,
input_sizes: &[i64],
dim: i64,
index: i64
) -> Result<Tensor, TchError>
pub fn f_select_scatter(
&self,
src: &Tensor,
dim: i64,
index: i64
) -> Result<Tensor, TchError>
pub fn f_selu(&self) -> Result<Tensor, TchError>
pub fn f_selu_(&mut self) -> Result<Tensor, TchError>
pub fn f_set_(&mut self) -> Result<Tensor, TchError>
pub fn f_set_data(&mut self, new_data: &Tensor) -> Result<(), TchError>
pub fn f_set_requires_grad(&self, r: bool) -> Result<Tensor, TchError>
pub fn f_set_source_tensor_(
&mut self,
source: &Tensor
) -> Result<Tensor, TchError>
pub fn f_sgn(&self) -> Result<Tensor, TchError>
pub fn f_sgn_(&mut self) -> Result<Tensor, TchError>
pub fn f_sgn_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_sigmoid(&self) -> Result<Tensor, TchError>
pub fn f_sigmoid_(&mut self) -> Result<Tensor, TchError>
pub fn f_sigmoid_backward(
grad_output: &Tensor,
output: &Tensor
) -> Result<Tensor, TchError>
pub fn f_sigmoid_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output: &Tensor
) -> Result<Tensor, TchError>
pub fn f_sigmoid_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_sign(&self) -> Result<Tensor, TchError>
pub fn f_sign_(&mut self) -> Result<Tensor, TchError>
pub fn f_sign_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_signbit(&self) -> Result<Tensor, TchError>
pub fn f_signbit_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_silu(&self) -> Result<Tensor, TchError>
pub fn f_silu_(&mut self) -> Result<Tensor, TchError>
pub fn f_silu_backward(&self, grad_output: &Tensor) -> Result<Tensor, TchError>
pub fn f_silu_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor
) -> Result<Tensor, TchError>
pub fn f_silu_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_sin(&self) -> Result<Tensor, TchError>
pub fn f_sin_(&mut self) -> Result<Tensor, TchError>
pub fn f_sin_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_sinc(&self) -> Result<Tensor, TchError>
pub fn f_sinc_(&mut self) -> Result<Tensor, TchError>
pub fn f_sinc_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_sinh(&self) -> Result<Tensor, TchError>
pub fn f_sinh_(&mut self) -> Result<Tensor, TchError>
pub fn f_sinh_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_slice(
&self,
dim: i64,
start: impl Into<Option<i64>>,
end: impl Into<Option<i64>>,
step: i64
) -> Result<Tensor, TchError>
pub fn f_slice_backward(
grad_output: &Tensor,
input_sizes: &[i64],
dim: i64,
start: i64,
end: i64,
step: i64
) -> Result<Tensor, TchError>
pub fn f_slice_scatter(
&self,
src: &Tensor,
dim: i64,
start: impl Into<Option<i64>>,
end: impl Into<Option<i64>>,
step: i64
) -> Result<Tensor, TchError>
pub fn f_slogdet(&self) -> Result<(Tensor, Tensor), TchError>
pub fn f_slow_conv3d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
kernel_size: &[i64],
bias: Option<T>,
stride: &[i64],
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_slow_conv3d_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
weight: &Tensor,
kernel_size: &[i64],
bias: Option<T>,
stride: &[i64],
padding: &[i64]
) -> Result<Tensor, TchError>
pub fn f_slow_conv_dilated2d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
kernel_size: &[i64],
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64]
) -> Result<Tensor, TchError>
pub fn f_slow_conv_dilated3d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
kernel_size: &[i64],
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64]
) -> Result<Tensor, TchError>
pub fn f_slow_conv_transpose2d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
kernel_size: &[i64],
bias: Option<T>,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
dilation: &[i64]
) -> Result<Tensor, TchError>
pub fn f_slow_conv_transpose2d_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
weight: &Tensor,
kernel_size: &[i64],
bias: Option<T>,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
dilation: &[i64]
) -> Result<Tensor, TchError>
pub fn f_slow_conv_transpose3d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
kernel_size: &[i64],
bias: Option<T>,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
dilation: &[i64]
) -> Result<Tensor, TchError>
pub fn f_slow_conv_transpose3d_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
weight: &Tensor,
kernel_size: &[i64],
bias: Option<T>,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
dilation: &[i64]
) -> Result<Tensor, TchError>
pub fn f_smm(&self, mat2: &Tensor) -> Result<Tensor, TchError>
pub fn f_smooth_l1_loss(
&self,
target: &Tensor,
reduction: Reduction,
beta: f64
) -> Result<Tensor, TchError>
pub fn f_smooth_l1_loss_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction,
beta: f64
) -> Result<Tensor, TchError>
pub fn f_smooth_l1_loss_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction,
beta: f64
) -> Result<Tensor, TchError>
pub fn f_smooth_l1_loss_out(
&self,
out: &Tensor,
target: &Tensor,
reduction: Reduction,
beta: f64
) -> Result<Tensor, TchError>
pub fn f_soft_margin_loss(
&self,
target: &Tensor,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_soft_margin_loss_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_soft_margin_loss_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_soft_margin_loss_out(
&self,
out: &Tensor,
target: &Tensor,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_softmax(&self, dim: i64, dtype: Kind) -> Result<Tensor, TchError>
pub fn f_softplus(&self) -> Result<Tensor, TchError>
pub fn f_softplus_backward<S: Into<Scalar>>(
&self,
grad_output: &Tensor,
beta: S,
threshold: S
) -> Result<Tensor, TchError>
pub fn f_softplus_backward_grad_input<S: Into<Scalar>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
beta: S,
threshold: S
) -> Result<Tensor, TchError>
pub fn f_softplus_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_softshrink(&self) -> Result<Tensor, TchError>
pub fn f_softshrink_backward<S: Into<Scalar>>(
&self,
grad_output: &Tensor,
lambd: S
) -> Result<Tensor, TchError>
pub fn f_softshrink_backward_grad_input<S: Into<Scalar>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
lambd: S
) -> Result<Tensor, TchError>
pub fn f_softshrink_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_solve(&self, a: &Tensor) -> Result<(Tensor, Tensor), TchError>
pub fn f_solve_solution(
&self,
solution: &Tensor,
lu: &Tensor,
a: &Tensor
) -> Result<(Tensor, Tensor), TchError>
pub fn f_sort(
&self,
dim: i64,
descending: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_sort_stable(
&self,
stable: bool,
dim: i64,
descending: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_sort_values(
&self,
values: &Tensor,
indices: &Tensor,
dim: i64,
descending: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_sort_values_stable(
&self,
values: &Tensor,
indices: &Tensor,
stable: bool,
dim: i64,
descending: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_sparse_coo_tensor(
size: &[i64],
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_sparse_coo_tensor_indices(
indices: &Tensor,
values: &Tensor,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_sparse_coo_tensor_indices_size(
indices: &Tensor,
values: &Tensor,
size: &[i64],
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_sparse_csr_tensor(
crow_indices: &Tensor,
col_indices: &Tensor,
values: &Tensor,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_sparse_csr_tensor_crow_col_value_size(
crow_indices: &Tensor,
col_indices: &Tensor,
values: &Tensor,
size: &[i64],
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_sparse_dim(&self) -> Result<i64, TchError>
pub fn f_sparse_mask(&self, mask: &Tensor) -> Result<Tensor, TchError>
pub fn f_sparse_resize_(
&mut self,
size: &[i64],
sparse_dim: i64,
dense_dim: i64
) -> Result<Tensor, TchError>
pub fn f_sparse_resize_and_clear_(
&mut self,
size: &[i64],
sparse_dim: i64,
dense_dim: i64
) -> Result<Tensor, TchError>
pub fn f_sparse_sampled_addmm(
&self,
mat1: &Tensor,
mat2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_sparse_sampled_addmm_out(
&self,
out: &Tensor,
mat1: &Tensor,
mat2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_special_digamma(&self) -> Result<Tensor, TchError>
pub fn f_special_digamma_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_entr(&self) -> Result<Tensor, TchError>
pub fn f_special_entr_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_erf(&self) -> Result<Tensor, TchError>
pub fn f_special_erf_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_erfc(&self) -> Result<Tensor, TchError>
pub fn f_special_erfc_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_erfcx(&self) -> Result<Tensor, TchError>
pub fn f_special_erfcx_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_erfinv(&self) -> Result<Tensor, TchError>
pub fn f_special_erfinv_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_exp2(&self) -> Result<Tensor, TchError>
pub fn f_special_exp2_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_expit(&self) -> Result<Tensor, TchError>
pub fn f_special_expit_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_expm1(&self) -> Result<Tensor, TchError>
pub fn f_special_expm1_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_gammainc(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_gammainc_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_special_gammaincc(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_gammaincc_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_special_gammaln(&self) -> Result<Tensor, TchError>
pub fn f_special_gammaln_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_i0(&self) -> Result<Tensor, TchError>
pub fn f_special_i0_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_i0e(&self) -> Result<Tensor, TchError>
pub fn f_special_i0e_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_i1(&self) -> Result<Tensor, TchError>
pub fn f_special_i1_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_i1e(&self) -> Result<Tensor, TchError>
pub fn f_special_i1e_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_log1p(&self) -> Result<Tensor, TchError>
pub fn f_special_log1p_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_log_softmax(
&self,
dim: i64,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_special_logit(
&self,
eps: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_special_logit_out(
&self,
out: &Tensor,
eps: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_special_logsumexp(
&self,
dim: &[i64],
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_special_logsumexp_out(
&self,
out: &Tensor,
dim: &[i64],
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_special_multigammaln(&self, p: i64) -> Result<Tensor, TchError>
pub fn f_special_multigammaln_out(
&self,
out: &Tensor,
p: i64
) -> Result<Tensor, TchError>
pub fn f_special_ndtr(&self) -> Result<Tensor, TchError>
pub fn f_special_ndtr_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_ndtri(&self) -> Result<Tensor, TchError>
pub fn f_special_ndtri_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_polygamma(&self, n: i64) -> Result<Tensor, TchError>
pub fn f_special_polygamma_out(
&self,
out: &Tensor,
n: i64
) -> Result<Tensor, TchError>
pub fn f_special_psi(&self) -> Result<Tensor, TchError>
pub fn f_special_psi_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_round(&self, decimals: i64) -> Result<Tensor, TchError>
pub fn f_special_round_out(
&self,
out: &Tensor,
decimals: i64
) -> Result<Tensor, TchError>
pub fn f_special_sinc(&self) -> Result<Tensor, TchError>
pub fn f_special_sinc_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_softmax(
&self,
dim: i64,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_special_xlog1py(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_xlog1py_other_scalar<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_special_xlog1py_other_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_special_xlog1py_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_special_xlog1py_self_scalar<S: Into<Scalar>>(
self_scalar: S,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_special_xlog1py_self_scalar_out<S: Into<Scalar>>(
out: &Tensor,
self_scalar: S,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_special_xlogy(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_xlogy_other_scalar<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_special_xlogy_other_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_special_xlogy_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_special_xlogy_self_scalar<S: Into<Scalar>>(
self_scalar: S,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_special_xlogy_self_scalar_out<S: Into<Scalar>>(
out: &Tensor,
self_scalar: S,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_special_zeta(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_special_zeta_other_scalar<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_special_zeta_other_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_special_zeta_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_special_zeta_self_scalar<S: Into<Scalar>>(
self_scalar: S,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_special_zeta_self_scalar_out<S: Into<Scalar>>(
out: &Tensor,
self_scalar: S,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_split(
&self,
split_size: i64,
dim: i64
) -> Result<Vec<Tensor>, TchError>
pub fn f_split_with_sizes(
&self,
split_sizes: &[i64],
dim: i64
) -> Result<Vec<Tensor>, TchError>
pub fn f_sqrt(&self) -> Result<Tensor, TchError>
pub fn f_sqrt_(&mut self) -> Result<Tensor, TchError>
pub fn f_sqrt_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_square(&self) -> Result<Tensor, TchError>
pub fn f_square_(&mut self) -> Result<Tensor, TchError>
pub fn f_square_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_squeeze(&self) -> Result<Tensor, TchError>
pub fn f_squeeze_(&mut self) -> Result<Tensor, TchError>
pub fn f_squeeze_dim(&self, dim: i64) -> Result<Tensor, TchError>
pub fn f_squeeze_dim_(&mut self, dim: i64) -> Result<Tensor, TchError>
pub fn f_sspaddmm(
&self,
mat1: &Tensor,
mat2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_sspaddmm_out(
&self,
out: &Tensor,
mat1: &Tensor,
mat2: &Tensor
) -> Result<Tensor, TchError>
pub fn f_stack<T: Borrow<Tensor>>(
tensors: &[T],
dim: i64
) -> Result<Tensor, TchError>
pub fn f_stack_out<T: Borrow<Tensor>>(
out: &Tensor,
tensors: &[T],
dim: i64
) -> Result<Tensor, TchError>
pub fn f_std(&self, unbiased: bool) -> Result<Tensor, TchError>
pub fn f_std_correction<'a>(
&self,
dim: impl Into<Option<&'a [i64]>>,
correction: impl Into<Option<i64>>,
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_std_correction_out<'a>(
&self,
out: &Tensor,
dim: impl Into<Option<&'a [i64]>>,
correction: impl Into<Option<i64>>,
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_std_dim(
&self,
dim: &[i64],
unbiased: bool,
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_std_mean(&self, unbiased: bool) -> Result<(Tensor, Tensor), TchError>
pub fn f_std_mean_correction<'a>(
&self,
dim: impl Into<Option<&'a [i64]>>,
correction: impl Into<Option<i64>>,
keepdim: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_std_mean_dim(
&self,
dim: &[i64],
unbiased: bool,
keepdim: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_std_out(
&self,
out: &Tensor,
dim: &[i64],
unbiased: bool,
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_stft<T: Borrow<Tensor>>(
&self,
n_fft: i64,
hop_length: impl Into<Option<i64>>,
win_length: impl Into<Option<i64>>,
window: Option<T>,
normalized: bool,
onesided: bool,
return_complex: bool
) -> Result<Tensor, TchError>
pub fn f_sub(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_sub_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_sub_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_sub_scalar<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_sub_scalar_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_subtract(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_subtract_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_subtract_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_subtract_scalar<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_subtract_scalar_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_sum(&self, dtype: Kind) -> Result<Tensor, TchError>
pub fn f_sum_dim_intlist(
&self,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_sum_intlist_out(
&self,
out: &Tensor,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Result<Tensor, TchError>
pub fn f_sum_to_size(&self, size: &[i64]) -> Result<Tensor, TchError>
pub fn f_svd(
&self,
some: bool,
compute_uv: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_svd_u(
&self,
u: &Tensor,
s: &Tensor,
v: &Tensor,
some: bool,
compute_uv: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_swapaxes(&self, axis0: i64, axis1: i64) -> Result<Tensor, TchError>
pub fn f_swapaxes_(
&mut self,
axis0: i64,
axis1: i64
) -> Result<Tensor, TchError>
pub fn f_swapdims(&self, dim0: i64, dim1: i64) -> Result<Tensor, TchError>
pub fn f_swapdims_(&mut self, dim0: i64, dim1: i64) -> Result<Tensor, TchError>
pub fn f_symeig(
&self,
eigenvectors: bool,
upper: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_symeig_e(
&self,
e: &Tensor,
v: &Tensor,
eigenvectors: bool,
upper: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_tr(&self) -> Result<Tensor, TchError>
pub fn f_t_(&mut self) -> Result<Tensor, TchError>
pub fn f_take(&self, index: &Tensor) -> Result<Tensor, TchError>
pub fn f_take_along_dim(
&self,
indices: &Tensor,
dim: impl Into<Option<i64>>
) -> Result<Tensor, TchError>
pub fn f_take_along_dim_out(
&self,
out: &Tensor,
indices: &Tensor,
dim: impl Into<Option<i64>>
) -> Result<Tensor, TchError>
pub fn f_take_out(
&self,
out: &Tensor,
index: &Tensor
) -> Result<Tensor, TchError>
pub fn f_tan(&self) -> Result<Tensor, TchError>
pub fn f_tan_(&mut self) -> Result<Tensor, TchError>
pub fn f_tan_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_tanh(&self) -> Result<Tensor, TchError>
pub fn f_tanh_(&mut self) -> Result<Tensor, TchError>
pub fn f_tanh_backward(
grad_output: &Tensor,
output: &Tensor
) -> Result<Tensor, TchError>
pub fn f_tanh_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output: &Tensor
) -> Result<Tensor, TchError>
pub fn f_tanh_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_tensor_split(
&self,
sections: i64,
dim: i64
) -> Result<Vec<Tensor>, TchError>
pub fn f_tensor_split_indices(
&self,
indices: &[i64],
dim: i64
) -> Result<Vec<Tensor>, TchError>
pub fn f_tensor_split_tensor_indices_or_sections(
&self,
tensor_indices_or_sections: &Tensor,
dim: i64
) -> Result<Vec<Tensor>, TchError>
pub fn f_tensordot(
&self,
other: &Tensor,
dims_self: &[i64],
dims_other: &[i64]
) -> Result<Tensor, TchError>
pub fn f_tensordot_out(
&self,
out: &Tensor,
other: &Tensor,
dims_self: &[i64],
dims_other: &[i64]
) -> Result<Tensor, TchError>
pub fn f_threshold<S: Into<Scalar>>(
&self,
threshold: S,
value: S
) -> Result<Tensor, TchError>
pub fn f_threshold_<S: Into<Scalar>>(
&mut self,
threshold: S,
value: S
) -> Result<Tensor, TchError>
pub fn f_threshold_backward<S: Into<Scalar>>(
&self,
grad_output: &Tensor,
threshold: S
) -> Result<Tensor, TchError>
pub fn f_threshold_backward_grad_input<S: Into<Scalar>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
threshold: S
) -> Result<Tensor, TchError>
pub fn f_threshold_out<S: Into<Scalar>>(
&self,
out: &Tensor,
threshold: S,
value: S
) -> Result<Tensor, TchError>
pub fn f_tile(&self, dims: &[i64]) -> Result<Tensor, TchError>
pub fn f_to(&self, device: Device) -> Result<Tensor, TchError>
pub fn f_to_dense(&self, dtype: Kind) -> Result<Tensor, TchError>
pub fn f_to_dense_backward(&self, grad: &Tensor) -> Result<Tensor, TchError>
pub fn f_to_device_(
&self,
device: Device,
dtype: Kind,
non_blocking: bool,
copy: bool
) -> Result<Tensor, TchError>
pub fn f_to_dtype(
&self,
dtype: Kind,
non_blocking: bool,
copy: bool
) -> Result<Tensor, TchError>
pub fn f_to_dtype_layout(
&self,
options: (Kind, Device),
non_blocking: bool,
copy: bool
) -> Result<Tensor, TchError>
pub fn f_to_mkldnn(&self, dtype: Kind) -> Result<Tensor, TchError>
pub fn f_to_mkldnn_backward(&self, grad: &Tensor) -> Result<Tensor, TchError>
pub fn f_to_other(
&self,
other: &Tensor,
non_blocking: bool,
copy: bool
) -> Result<Tensor, TchError>
pub fn f_to_sparse(&self) -> Result<Tensor, TchError>
pub fn f_to_sparse_sparse_dim(
&self,
sparse_dim: i64
) -> Result<Tensor, TchError>
pub fn f_topk(
&self,
k: i64,
dim: i64,
largest: bool,
sorted: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_topk_values(
&self,
values: &Tensor,
indices: &Tensor,
k: i64,
dim: i64,
largest: bool,
sorted: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_totype(&self, scalar_type: Kind) -> Result<Tensor, TchError>
pub fn f_trace(&self) -> Result<Tensor, TchError>
pub fn f_trace_backward(
grad: &Tensor,
sizes: &[i64]
) -> Result<Tensor, TchError>
pub fn f_transpose(&self, dim0: i64, dim1: i64) -> Result<Tensor, TchError>
pub fn f_transpose_(&mut self, dim0: i64, dim1: i64) -> Result<Tensor, TchError>
pub fn f_trapezoid(y: &Tensor, dim: i64) -> Result<Tensor, TchError>
pub fn f_trapezoid_x(
y: &Tensor,
x: &Tensor,
dim: i64
) -> Result<Tensor, TchError>
pub fn f_trapz(y: &Tensor, x: &Tensor, dim: i64) -> Result<Tensor, TchError>
pub fn f_trapz_dx(y: &Tensor, dx: f64, dim: i64) -> Result<Tensor, TchError>
pub fn f_triangular_solve(
&self,
a: &Tensor,
upper: bool,
transpose: bool,
unitriangular: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_triangular_solve_x(
&self,
x: &Tensor,
m: &Tensor,
a: &Tensor,
upper: bool,
transpose: bool,
unitriangular: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_tril(&self, diagonal: i64) -> Result<Tensor, TchError>
pub fn f_tril_(&mut self, diagonal: i64) -> Result<Tensor, TchError>
pub fn f_tril_indices(
row: i64,
col: i64,
offset: i64,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_tril_out(
&self,
out: &Tensor,
diagonal: i64
) -> Result<Tensor, TchError>
pub fn f_triplet_margin_loss(
anchor: &Tensor,
positive: &Tensor,
negative: &Tensor,
margin: f64,
p: f64,
eps: f64,
swap: bool,
reduction: Reduction
) -> Result<Tensor, TchError>
pub fn f_triu(&self, diagonal: i64) -> Result<Tensor, TchError>
pub fn f_triu_(&mut self, diagonal: i64) -> Result<Tensor, TchError>
pub fn f_triu_indices(
row: i64,
col: i64,
offset: i64,
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_triu_out(
&self,
out: &Tensor,
diagonal: i64
) -> Result<Tensor, TchError>
pub fn f_true_divide(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_true_divide_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_true_divide_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_true_divide_scalar<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_true_divide_scalar_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_trunc(&self) -> Result<Tensor, TchError>
pub fn f_trunc_(&mut self) -> Result<Tensor, TchError>
pub fn f_trunc_out(&self, out: &Tensor) -> Result<Tensor, TchError>
pub fn f_type_as(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_unbind(&self, dim: i64) -> Result<Vec<Tensor>, TchError>
pub fn f_unflatten(&self, dim: i64, sizes: &[i64]) -> Result<Tensor, TchError>
pub fn f_unflatten_dense_tensors<T: Borrow<Tensor>>(
flat: &Tensor,
tensors: &[T]
) -> Result<Vec<Tensor>, TchError>
pub fn f_unfold(
&self,
dimension: i64,
size: i64,
step: i64
) -> Result<Tensor, TchError>
pub fn f_unfold_backward(
grad_in: &Tensor,
input_sizes: &[i64],
dim: i64,
size: i64,
step: i64
) -> Result<Tensor, TchError>
pub fn f_uniform_(&mut self, from: f64, to: f64) -> Result<Tensor, TchError>
pub fn f_unique_consecutive(
&self,
return_inverse: bool,
return_counts: bool,
dim: impl Into<Option<i64>>
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_unique_dim(
&self,
dim: i64,
sorted: bool,
return_inverse: bool,
return_counts: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_unique_dim_consecutive(
&self,
dim: i64,
return_inverse: bool,
return_counts: bool
) -> Result<(Tensor, Tensor, Tensor), TchError>
pub fn f_unsafe_chunk(
&self,
chunks: i64,
dim: i64
) -> Result<Vec<Tensor>, TchError>
pub fn f_unsafe_split(
&self,
split_size: i64,
dim: i64
) -> Result<Vec<Tensor>, TchError>
pub fn f_unsafe_split_with_sizes(
&self,
split_sizes: &[i64],
dim: i64
) -> Result<Vec<Tensor>, TchError>
pub fn f_unsqueeze(&self, dim: i64) -> Result<Tensor, TchError>
pub fn f_unsqueeze_(&mut self, dim: i64) -> Result<Tensor, TchError>
pub fn f_upsample_bicubic2d(
&self,
output_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_bicubic2d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_bicubic2d_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_bicubic2d_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
align_corners: bool,
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_upsample_bicubic2d_out(
&self,
out: &Tensor,
output_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_bicubic2d_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
align_corners: bool,
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_upsample_bilinear2d(
&self,
output_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_bilinear2d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_bilinear2d_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_bilinear2d_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
align_corners: bool,
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_upsample_bilinear2d_out(
&self,
out: &Tensor,
output_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_bilinear2d_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
align_corners: bool,
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_upsample_linear1d(
&self,
output_size: &[i64],
align_corners: bool,
scales: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_linear1d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_linear1d_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_linear1d_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
align_corners: bool,
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_upsample_linear1d_out(
&self,
out: &Tensor,
output_size: &[i64],
align_corners: bool,
scales: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_linear1d_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
align_corners: bool,
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_upsample_nearest1d(
&self,
output_size: &[i64],
scales: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_nearest1d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_nearest1d_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_nearest1d_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_upsample_nearest1d_out(
&self,
out: &Tensor,
output_size: &[i64],
scales: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_nearest1d_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_upsample_nearest2d(
&self,
output_size: &[i64],
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_nearest2d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_nearest2d_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_nearest2d_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_upsample_nearest2d_out(
&self,
out: &Tensor,
output_size: &[i64],
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_nearest2d_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_upsample_nearest3d(
&self,
output_size: &[i64],
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_nearest3d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_nearest3d_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_nearest3d_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_upsample_nearest3d_out(
&self,
out: &Tensor,
output_size: &[i64],
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_nearest3d_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_upsample_trilinear3d(
&self,
output_size: &[i64],
align_corners: bool,
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_trilinear3d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_trilinear3d_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_trilinear3d_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
align_corners: bool,
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_upsample_trilinear3d_out(
&self,
out: &Tensor,
output_size: &[i64],
align_corners: bool,
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Result<Tensor, TchError>
pub fn f_upsample_trilinear3d_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
align_corners: bool,
scale_factors: &[f64]
) -> Result<Tensor, TchError>
pub fn f_value_selecting_reduction_backward(
grad: &Tensor,
dim: i64,
indices: &Tensor,
sizes: &[i64],
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_values(&self) -> Result<Tensor, TchError>
pub fn f_vander(
x: &Tensor,
n: impl Into<Option<i64>>,
increasing: bool
) -> Result<Tensor, TchError>
pub fn f_var(&self, unbiased: bool) -> Result<Tensor, TchError>
pub fn f_var_correction<'a>(
&self,
dim: impl Into<Option<&'a [i64]>>,
correction: impl Into<Option<i64>>,
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_var_correction_out<'a>(
&self,
out: &Tensor,
dim: impl Into<Option<&'a [i64]>>,
correction: impl Into<Option<i64>>,
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_var_dim(
&self,
dim: &[i64],
unbiased: bool,
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_var_mean(&self, unbiased: bool) -> Result<(Tensor, Tensor), TchError>
pub fn f_var_mean_correction<'a>(
&self,
dim: impl Into<Option<&'a [i64]>>,
correction: impl Into<Option<i64>>,
keepdim: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_var_mean_dim(
&self,
dim: &[i64],
unbiased: bool,
keepdim: bool
) -> Result<(Tensor, Tensor), TchError>
pub fn f_var_out(
&self,
out: &Tensor,
dim: &[i64],
unbiased: bool,
keepdim: bool
) -> Result<Tensor, TchError>
pub fn f_vdot(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_vdot_out(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_view_(&self, size: &[i64]) -> Result<Tensor, TchError>
pub fn f_view_as(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_view_as_complex(&self) -> Result<Tensor, TchError>
pub fn f_view_as_real(&self) -> Result<Tensor, TchError>
pub fn f_view_dtype(&self, dtype: Kind) -> Result<Tensor, TchError>
pub fn f_vsplit(&self, sections: i64) -> Result<Vec<Tensor>, TchError>
pub fn f_vsplit_array(&self, indices: &[i64]) -> Result<Vec<Tensor>, TchError>
pub fn f_vstack<T: Borrow<Tensor>>(tensors: &[T]) -> Result<Tensor, TchError>
pub fn f_vstack_out<T: Borrow<Tensor>>(
out: &Tensor,
tensors: &[T]
) -> Result<Tensor, TchError>
pub fn f_where_(condition: &Tensor) -> Result<Vec<Tensor>, TchError>
pub fn f_where_scalar<S: Into<Scalar>>(
condition: &Tensor,
self_scalar: S,
other: S
) -> Result<Tensor, TchError>
pub fn f_where_scalarother<S: Into<Scalar>>(
&self,
condition: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_where_scalarself<S: Into<Scalar>>(
condition: &Tensor,
self_scalar: S,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_where_self(
&self,
condition: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_xlogy(&self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_xlogy_(&mut self, other: &Tensor) -> Result<Tensor, TchError>
pub fn f_xlogy_outscalar_other<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Result<Tensor, TchError>
pub fn f_xlogy_outscalar_self<S: Into<Scalar>>(
out: &Tensor,
self_scalar: S,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_xlogy_outtensor(
&self,
out: &Tensor,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_xlogy_scalar_other<S: Into<Scalar>>(
&self,
other: S
) -> Result<Tensor, TchError>
pub fn f_xlogy_scalar_other_<S: Into<Scalar>>(
&mut self,
other: S
) -> Result<Tensor, TchError>
pub fn f_xlogy_scalar_self<S: Into<Scalar>>(
self_scalar: S,
other: &Tensor
) -> Result<Tensor, TchError>
pub fn f_zero_(&mut self) -> Result<Tensor, TchError>
pub fn f_zeros(
size: &[i64],
options: (Kind, Device)
) -> Result<Tensor, TchError>
pub fn f_zeros_like(&self) -> Result<Tensor, TchError>
pub fn f_zeros_out(out: &Tensor, size: &[i64]) -> Result<Tensor, TchError>
sourceimpl Tensor
impl Tensor
pub fn internal_and_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn internal_and_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn internal_iand_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn internal_iand_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn internal_ilshift_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn internal_ilshift_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn internal_ior_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn internal_ior_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn internal_irshift_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn internal_irshift_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn internal_ixor_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn internal_ixor_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn internal_lshift_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn internal_lshift_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn internal_or_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn internal_or_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn internal_rshift_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn internal_rshift_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn internal_xor_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn internal_xor_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn internal_adaptive_avg_pool2d(&self, output_size: &[i64]) -> Tensor
pub fn internal_adaptive_avg_pool2d_backward(
&self,
grad_output: &Tensor
) -> Tensor
pub fn internal_adaptive_avg_pool3d(&self, output_size: &[i64]) -> Tensor
pub fn internal_adaptive_avg_pool3d_backward(
&self,
grad_output: &Tensor
) -> Tensor
pub fn internal_add_batch_dim(&self, batch_dim: i64, level: i64) -> Tensor
pub fn internal_add_relu(&self, other: &Tensor) -> Tensor
pub fn internal_add_relu_(&mut self, other: &Tensor) -> Tensor
pub fn internal_add_relu_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn internal_add_relu_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn internal_add_relu_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn internal_aminmax(&self) -> (Tensor, Tensor)
pub fn internal_aminmax_dim(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)
pub fn internal_amp_update_scale_(
&mut self,
growth_tracker: &Tensor,
found_inf: &Tensor,
scale_growth_factor: f64,
scale_backoff_factor: f64,
growth_interval: i64
) -> Tensor
pub fn internal_autocast_to_full_precision(
&self,
cuda_enabled: bool,
cpu_enabled: bool
) -> Tensor
pub fn internal_autocast_to_reduced_precision(
&self,
cuda_enabled: bool,
cpu_enabled: bool,
cuda_dtype: Kind,
cpu_dtype: Kind
) -> Tensor
pub fn internal_cast_byte(&self, non_blocking: bool) -> Tensor
pub fn internal_cast_char(&self, non_blocking: bool) -> Tensor
pub fn internal_cast_double(&self, non_blocking: bool) -> Tensor
pub fn internal_cast_float(&self, non_blocking: bool) -> Tensor
pub fn internal_cast_half(&self, non_blocking: bool) -> Tensor
pub fn internal_cast_int(&self, non_blocking: bool) -> Tensor
pub fn internal_cast_long(&self, non_blocking: bool) -> Tensor
pub fn internal_cast_short(&self, non_blocking: bool) -> Tensor
pub fn internal_cat<T: Borrow<Tensor>>(tensors: &[T], dim: i64) -> Tensor
pub fn internal_cat_out<T: Borrow<Tensor>>(
out: &Tensor,
tensors: &[T],
dim: i64
) -> Tensor
pub fn internal_cdist_backward(
grad: &Tensor,
x1: &Tensor,
x2: &Tensor,
p: f64,
cdist: &Tensor
) -> Tensor
pub fn internal_cholesky_solve_helper(&self, a: &Tensor, upper: bool) -> Tensor
pub fn internal_coalesce(&self) -> Tensor
pub fn internal_coalesced_(&mut self, coalesced: bool) -> Tensor
pub fn internal_compute_linear_combination(
&self,
coefficients: &Tensor
) -> Tensor
pub fn internal_compute_linear_combination_out(
&self,
out: &Tensor,
coefficients: &Tensor
) -> Tensor
pub fn internal_conj(&self) -> Tensor
pub fn internal_conj_physical(&self) -> Tensor
pub fn internal_conv_depthwise2d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
kernel_size: &[i64],
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64]
) -> Tensor
pub fn internal_conv_depthwise2d_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
weight: &Tensor,
kernel_size: &[i64],
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64]
) -> Tensor
pub fn internal_convert_indices_from_coo_to_csr(
&self,
size: i64,
out_int32: bool
) -> Tensor
pub fn internal_convert_indices_from_coo_to_csr_out(
&self,
out: &Tensor,
size: i64,
out_int32: bool
) -> Tensor
pub fn internal_convert_indices_from_csr_to_coo(
crow_indices: &Tensor,
col_indices: &Tensor,
out_int32: bool,
transpose: bool
) -> Tensor
pub fn internal_convert_indices_from_csr_to_coo_out(
out: &Tensor,
crow_indices: &Tensor,
col_indices: &Tensor,
out_int32: bool,
transpose: bool
) -> Tensor
pub fn internal_convolution<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
transposed: bool,
output_padding: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool,
cudnn_enabled: bool,
allow_tf32: bool
) -> Tensor
pub fn internal_convolution_deprecated<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
transposed: bool,
output_padding: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool,
cudnn_enabled: bool
) -> Tensor
pub fn internal_convolution_mode<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &str,
dilation: &[i64],
groups: i64
) -> Tensor
pub fn internal_copy_from(&self, dst: &Tensor, non_blocking: bool) -> Tensor
pub fn internal_copy_from_and_resize(&self, dst: &Tensor) -> Tensor
pub fn internal_ctc_loss(
log_probs: &Tensor,
targets: &Tensor,
input_lengths: &[i64],
target_lengths: &[i64],
blank: i64,
zero_infinity: bool
) -> (Tensor, Tensor)
pub fn internal_ctc_loss_backward(
grad: &Tensor,
log_probs: &Tensor,
targets: &Tensor,
input_lengths: &[i64],
target_lengths: &[i64],
neg_log_likelihood: &Tensor,
log_alpha: &Tensor,
blank: i64,
zero_infinity: bool
) -> Tensor
pub fn internal_cudnn_ctc_loss(
log_probs: &Tensor,
targets: &Tensor,
input_lengths: &[i64],
target_lengths: &[i64],
blank: i64,
deterministic: bool,
zero_infinity: bool
) -> (Tensor, Tensor)
pub fn internal_cudnn_init_dropout_state(
dropout: f64,
train: bool,
dropout_seed: i64,
options: (Kind, Device)
) -> Tensor
pub fn internal_cudnn_rnn<T: Borrow<Tensor>>(
&self,
weight: &[T],
weight_stride0: i64,
weight_buf: Option<T>,
hx: &Tensor,
cx: Option<T>,
mode: i64,
hidden_size: i64,
proj_size: i64,
num_layers: i64,
batch_first: bool,
dropout: f64,
train: bool,
bidirectional: bool,
batch_sizes: &[i64],
dropout_state: Option<T>
) -> (Tensor, Tensor, Tensor, Tensor, Tensor)
pub fn internal_cudnn_rnn_flatten_weight<T: Borrow<Tensor>>(
weight_arr: &[T],
weight_stride0: i64,
input_size: i64,
mode: i64,
hidden_size: i64,
proj_size: i64,
num_layers: i64,
batch_first: bool,
bidirectional: bool
) -> Tensor
pub fn internal_cufft_get_plan_cache_max_size(device_index: i64) -> i64
pub fn internal_cufft_get_plan_cache_size(device_index: i64) -> i64
pub fn internal_debug_has_internal_overlap(&self) -> i64
pub fn internal_det_lu_based_helper(&self) -> (Tensor, Tensor, Tensor)
pub fn internal_det_lu_based_helper_backward_helper(
&self,
det_grad: &Tensor,
det: &Tensor,
lu: &Tensor,
pivs: &Tensor
) -> Tensor
pub fn internal_dim_arange(like: &Tensor, dim: i64) -> Tensor
pub fn internal_dimi(&self) -> i64
pub fn internal_dimv(&self) -> i64
pub fn internal_dirichlet_grad(
x: &Tensor,
alpha: &Tensor,
total: &Tensor
) -> Tensor
pub fn internal_efficientzerotensor(
size: &[i64],
options: (Kind, Device)
) -> Tensor
pub fn internal_embedding_bag<T: Borrow<Tensor>>(
weight: &Tensor,
indices: &Tensor,
offsets: &Tensor,
scale_grad_by_freq: bool,
mode: i64,
sparse: bool,
per_sample_weights: Option<T>,
include_last_offset: bool,
padding_idx: i64
) -> (Tensor, Tensor, Tensor, Tensor)
pub fn internal_embedding_bag_backward<T: Borrow<Tensor>>(
grad: &Tensor,
indices: &Tensor,
offsets: &Tensor,
offset2bag: &Tensor,
bag_size: &Tensor,
maximum_indices: &Tensor,
num_weights: i64,
scale_grad_by_freq: bool,
mode: i64,
sparse: bool,
per_sample_weights: Option<T>,
padding_idx: i64
) -> Tensor
pub fn internal_embedding_bag_dense_backward<T: Borrow<Tensor>>(
grad: &Tensor,
indices: &Tensor,
offset2bag: &Tensor,
bag_size: &Tensor,
maximum_indices: &Tensor,
num_weights: i64,
scale_grad_by_freq: bool,
mode: i64,
per_sample_weights: Option<T>,
padding_idx: i64
) -> Tensor
pub fn internal_embedding_bag_forward_only<T: Borrow<Tensor>>(
weight: &Tensor,
indices: &Tensor,
offsets: &Tensor,
scale_grad_by_freq: bool,
mode: i64,
sparse: bool,
per_sample_weights: Option<T>,
include_last_offset: bool,
padding_idx: i64
) -> (Tensor, Tensor, Tensor, Tensor)
pub fn internal_embedding_bag_per_sample_weights_backward(
grad: &Tensor,
weight: &Tensor,
indices: &Tensor,
offsets: &Tensor,
offset2bag: &Tensor,
mode: i64,
padding_idx: i64
) -> Tensor
pub fn internal_embedding_bag_sparse_backward<T: Borrow<Tensor>>(
grad: &Tensor,
indices: &Tensor,
offsets: &Tensor,
offset2bag: &Tensor,
bag_size: &Tensor,
num_weights: i64,
scale_grad_by_freq: bool,
mode: i64,
per_sample_weights: Option<T>,
padding_idx: i64
) -> Tensor
pub fn internal_empty_affine_quantized(
size: &[i64],
options: (Kind, Device),
scale: f64,
zero_point: i64
) -> Tensor
pub fn internal_empty_per_channel_affine_quantized(
size: &[i64],
scales: &Tensor,
zero_points: &Tensor,
axis: i64,
options: (Kind, Device)
) -> Tensor
pub fn internal_euclidean_dist(x1: &Tensor, x2: &Tensor) -> Tensor
pub fn internal_fake_quantize_learnable_per_channel_affine(
&self,
scale: &Tensor,
zero_point: &Tensor,
axis: i64,
quant_min: i64,
quant_max: i64,
grad_factor: f64
) -> Tensor
pub fn internal_fake_quantize_learnable_per_channel_affine_backward(
&self,
grad: &Tensor,
scale: &Tensor,
zero_point: &Tensor,
axis: i64,
quant_min: i64,
quant_max: i64,
grad_factor: f64
) -> (Tensor, Tensor, Tensor)
pub fn internal_fake_quantize_learnable_per_tensor_affine(
&self,
scale: &Tensor,
zero_point: &Tensor,
quant_min: i64,
quant_max: i64,
grad_factor: f64
) -> Tensor
pub fn internal_fake_quantize_learnable_per_tensor_affine_backward(
&self,
grad: &Tensor,
scale: &Tensor,
zero_point: &Tensor,
quant_min: i64,
quant_max: i64,
grad_factor: f64
) -> (Tensor, Tensor, Tensor)
pub fn internal_fake_quantize_per_tensor_affine_cachemask_tensor_qparams(
&self,
scale: &Tensor,
zero_point: &Tensor,
fake_quant_enabled: &Tensor,
quant_min: i64,
quant_max: i64
) -> (Tensor, Tensor)
pub fn internal_fft_c2c(
&self,
dim: &[i64],
normalization: i64,
forward: bool
) -> Tensor
pub fn internal_fft_c2c_out(
&self,
out: &Tensor,
dim: &[i64],
normalization: i64,
forward: bool
) -> Tensor
pub fn internal_fft_c2r(
&self,
dim: &[i64],
normalization: i64,
last_dim_size: i64
) -> Tensor
pub fn internal_fft_c2r_out(
&self,
out: &Tensor,
dim: &[i64],
normalization: i64,
last_dim_size: i64
) -> Tensor
pub fn internal_fft_r2c(
&self,
dim: &[i64],
normalization: i64,
onesided: bool
) -> Tensor
pub fn internal_fft_r2c_out(
&self,
out: &Tensor,
dim: &[i64],
normalization: i64,
onesided: bool
) -> Tensor
pub fn internal_fused_dropout(&self, p: f64) -> (Tensor, Tensor)
pub fn internal_fused_moving_avg_obs_fq_helper(
&self,
observer_on: &Tensor,
fake_quant_on: &Tensor,
running_min: &Tensor,
running_max: &Tensor,
scale: &Tensor,
zero_point: &Tensor,
averaging_const: f64,
quant_min: i64,
quant_max: i64,
ch_axis: i64,
per_row_fake_quant: bool,
symmetric_quant: bool
) -> (Tensor, Tensor)
pub fn internal_fw_primal(&self, level: i64) -> Tensor
pub fn internal_gather_sparse_backward(
&self,
dim: i64,
index: &Tensor,
grad: &Tensor
) -> Tensor
pub fn internal_grid_sampler_2d_cpu_fallback(
&self,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64,
align_corners: bool
) -> Tensor
pub fn internal_grid_sampler_2d_cpu_fallback_backward(
&self,
grad_output: &Tensor,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64,
align_corners: bool
) -> (Tensor, Tensor)
pub fn internal_has_compatible_shallow_copy_type(&self, from: &Tensor) -> bool
pub fn internal_has_same_storage_numel(&self, other: &Tensor) -> bool
pub fn internal_histogramdd_bin_edges<T: Borrow<Tensor>>(
&self,
bins: &[i64],
range: &[f64],
weight: Option<T>,
density: bool
) -> Vec<Tensor>
pub fn internal_histogramdd_from_bin_cts<T: Borrow<Tensor>>(
&self,
bins: &[i64],
range: &[f64],
weight: Option<T>,
density: bool
) -> Tensor
pub fn internal_histogramdd_from_bin_tensors<T: Borrow<Tensor>>(
&self,
bins: &[T],
weight: Option<T>,
density: bool
) -> Tensor
pub fn internal_index_copy_(
&mut self,
dim: i64,
index: &Tensor,
source: &Tensor
) -> Tensor
pub fn internal_index_put_impl_<T: Borrow<Tensor>>(
&mut self,
indices: &[Option<T>],
values: &Tensor,
accumulate: bool,
unsafe_: bool
) -> Tensor
pub fn internal_indices(&self) -> Tensor
pub fn internal_is_zerotensor(&self) -> bool
pub fn internal_linalg_check_errors(
info: &Tensor,
api_name: &str,
is_matrix: bool
)
pub fn internal_linalg_inv_out_helper_(
&mut self,
infos_lu: &Tensor,
infos_getri: &Tensor
) -> Tensor
pub fn internal_linalg_qr_helper(&self, mode: &str) -> (Tensor, Tensor)
pub fn internal_linalg_svd(
a: &Tensor,
full_matrices: bool,
compute_uv: bool
) -> (Tensor, Tensor, Tensor)
pub fn internal_linalg_svd_u(
u: &Tensor,
s: &Tensor,
vh: &Tensor,
a: &Tensor,
full_matrices: bool,
compute_uv: bool
) -> (Tensor, Tensor, Tensor)
pub fn internal_log_softmax(&self, dim: i64, half_to_float: bool) -> Tensor
pub fn internal_log_softmax_backward_data(
grad_output: &Tensor,
output: &Tensor,
dim: i64,
input_dtype: Kind
) -> Tensor
pub fn internal_log_softmax_backward_data_out(
out: &Tensor,
grad_output: &Tensor,
output: &Tensor,
dim: i64,
input_dtype: Kind
) -> Tensor
pub fn internal_log_softmax_out(
&self,
out: &Tensor,
dim: i64,
half_to_float: bool
) -> Tensor
pub fn internal_logcumsumexp(&self, dim: i64) -> Tensor
pub fn internal_logcumsumexp_out(&self, out: &Tensor, dim: i64) -> Tensor
pub fn internal_lu_with_info(
&self,
pivot: bool,
check_errors: bool
) -> (Tensor, Tensor, Tensor)
pub fn internal_make_dual(
primal: &Tensor,
tangent: &Tensor,
level: i64
) -> Tensor
pub fn internal_make_per_channel_quantized_tensor(
&self,
scale: &Tensor,
zero_point: &Tensor,
axis: i64
) -> Tensor
pub fn internal_make_per_tensor_quantized_tensor(
&self,
scale: f64,
zero_point: i64
) -> Tensor
pub fn internal_masked_scale(&self, mask: &Tensor, scale: f64) -> Tensor
pub fn internal_masked_softmax(&self, mask: &Tensor) -> Tensor
pub fn internal_mkldnn_reshape(&self, shape: &[i64]) -> Tensor
pub fn internal_mkldnn_transpose(&self, dim0: i64, dim1: i64) -> Tensor
pub fn internal_mkldnn_transpose_(&mut self, dim0: i64, dim1: i64) -> Tensor
pub fn internal_native_multi_head_self_attention<T: Borrow<Tensor>>(
query: &Tensor,
qkv_weight: &Tensor,
qkv_bias: &Tensor,
proj_weight: &Tensor,
proj_bias: &Tensor,
mask: Option<T>
) -> Tensor
pub fn internal_neg_view(&self) -> Tensor
pub fn internal_new_zeros_with_same_feature_meta(
&self,
other: &Tensor,
self_num_batch_dims: i64
) -> Tensor
pub fn internal_nnpack_available() -> bool
pub fn internal_nnpack_spatial_convolution<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
stride: &[i64]
) -> Tensor
pub fn internal_nnz(&self) -> i64
pub fn internal_pack_padded_sequence(
&self,
lengths: &Tensor,
batch_first: bool
) -> (Tensor, Tensor)
pub fn internal_pack_padded_sequence_backward(
grad: &Tensor,
input_size: &[i64],
batch_sizes: &Tensor,
batch_first: bool
) -> Tensor
pub fn internal_pad_packed_sequence<S: Into<Scalar>>(
data: &Tensor,
batch_sizes: &Tensor,
batch_first: bool,
padding_value: S,
total_length: i64
) -> (Tensor, Tensor)
pub fn internal_pdist_backward(
&self,
grad: &Tensor,
p: f64,
pdist: &Tensor
) -> Tensor
pub fn internal_pin_memory(&self, device: Device) -> Tensor
pub fn internal_remove_batch_dim(
&self,
level: i64,
batch_size: i64,
out_dim: i64
) -> Tensor
pub fn internal_reshape_alias(&self, size: &[i64], stride: &[i64]) -> Tensor
pub fn internal_reshape_from_tensor(&self, shape: &Tensor) -> Tensor
pub fn internal_rowwise_prune(
weight: &Tensor,
mask: &Tensor,
compressed_indices_dtype: Kind
) -> (Tensor, Tensor)
pub fn internal_s_where(&self, condition: &Tensor, other: &Tensor) -> Tensor
pub fn internal_sample_dirichlet(&self) -> Tensor
pub fn internal_saturate_weight_to_fp16(weight: &Tensor) -> Tensor
pub fn internal_segment_reduce_backward<T: Borrow<Tensor>>(
grad: &Tensor,
output: &Tensor,
data: &Tensor,
reduce: &str,
lengths: Option<T>,
axis: i64
) -> Tensor
pub fn internal_shape_as_tensor(&self) -> Tensor
pub fn internal_slow_conv2d_backward(
&self,
grad_input: &Tensor,
grad_weight: &Tensor,
grad_bias: &Tensor,
grad_output: &Tensor,
weight: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> (Tensor, Tensor, Tensor)
pub fn internal_sobol_engine_draw(
quasi: &Tensor,
n: i64,
sobolstate: &Tensor,
dimension: i64,
num_generated: i64,
dtype: Kind
) -> (Tensor, Tensor)
pub fn internal_sobol_engine_ff_(
&mut self,
n: i64,
sobolstate: &Tensor,
dimension: i64,
num_generated: i64
) -> Tensor
pub fn internal_sobol_engine_initialize_state_(
&mut self,
dimension: i64
) -> Tensor
pub fn internal_sobol_engine_scramble_(
&mut self,
ltm: &Tensor,
dimension: i64
) -> Tensor
pub fn internal_softmax(&self, dim: i64, half_to_float: bool) -> Tensor
pub fn internal_softmax_backward_data(
grad_output: &Tensor,
output: &Tensor,
dim: i64,
input_dtype: Kind
) -> Tensor
pub fn internal_softmax_backward_data_out(
grad_input: &Tensor,
grad_output: &Tensor,
output: &Tensor,
dim: i64,
input_dtype: Kind
) -> Tensor
pub fn internal_softmax_out(
&self,
out: &Tensor,
dim: i64,
half_to_float: bool
) -> Tensor
pub fn internal_solve_helper(&self, a: &Tensor) -> (Tensor, Tensor)
pub fn internal_sparse_addmm(&self, sparse: &Tensor, dense: &Tensor) -> Tensor
pub fn internal_sparse_broadcast_to(&self, size: &[i64]) -> Tensor
pub fn internal_sparse_coo_tensor_unsafe(
indices: &Tensor,
values: &Tensor,
size: &[i64],
options: (Kind, Device)
) -> Tensor
pub fn internal_sparse_coo_tensor_with_dims(
sparse_dim: i64,
dense_dim: i64,
size: &[i64],
options: (Kind, Device)
) -> Tensor
pub fn internal_sparse_coo_tensor_with_dims_and_tensors(
sparse_dim: i64,
dense_dim: i64,
size: &[i64],
indices: &Tensor,
values: &Tensor,
options: (Kind, Device)
) -> Tensor
pub fn internal_sparse_csr_tensor_unsafe(
crow_indices: &Tensor,
col_indices: &Tensor,
values: &Tensor,
size: &[i64],
options: (Kind, Device)
) -> Tensor
pub fn internal_sparse_log_softmax(
&self,
dim: i64,
half_to_float: bool
) -> Tensor
pub fn internal_sparse_log_softmax_backward_data(
&self,
grad_output: &Tensor,
output: &Tensor,
dim: i64
) -> Tensor
pub fn internal_sparse_log_softmax_int(&self, dim: i64, dtype: Kind) -> Tensor
pub fn internal_sparse_mask_helper(tr: &Tensor, mask_indices: &Tensor) -> Tensor
pub fn internal_sparse_mm(sparse: &Tensor, dense: &Tensor) -> Tensor
pub fn internal_sparse_softmax(&self, dim: i64, half_to_float: bool) -> Tensor
pub fn internal_sparse_softmax_backward_data(
&self,
grad_output: &Tensor,
output: &Tensor,
dim: i64
) -> Tensor
pub fn internal_sparse_softmax_int(&self, dim: i64, dtype: Kind) -> Tensor
pub fn internal_sparse_sparse_matmul(&self, other: &Tensor) -> Tensor
pub fn internal_sparse_sum(&self) -> Tensor
pub fn internal_sparse_sum_backward(&self, grad: &Tensor, dim: &[i64]) -> Tensor
pub fn internal_sparse_sum_dim(&self, dim: &[i64]) -> Tensor
pub fn internal_sparse_sum_dim_dtype(&self, dim: &[i64], dtype: Kind) -> Tensor
pub fn internal_sparse_sum_dtype(&self, dtype: Kind) -> Tensor
pub fn internal_stack<T: Borrow<Tensor>>(tensors: &[T], dim: i64) -> Tensor
pub fn internal_stack_out<T: Borrow<Tensor>>(
out: &Tensor,
tensors: &[T],
dim: i64
) -> Tensor
pub fn internal_standard_gamma(&self) -> Tensor
pub fn internal_standard_gamma_grad(&self, output: &Tensor) -> Tensor
pub fn internal_symeig_helper(
&self,
eigenvectors: bool,
upper: bool
) -> (Tensor, Tensor)
pub fn internal_test_ambiguous_defaults(
dummy: &Tensor,
a: i64,
b: i64
) -> Tensor
pub fn internal_test_ambiguous_defaults_b(
dummy: &Tensor,
a: i64,
b: &str
) -> Tensor
pub fn internal_test_optional_filled_intlist<'a>(
values: &Tensor,
addends: impl Into<Option<&'a [i64]>>
) -> Tensor
pub fn internal_test_optional_floatlist(
values: &Tensor,
addends: &[f64]
) -> Tensor
pub fn internal_test_optional_intlist<'a>(
values: &Tensor,
addends: impl Into<Option<&'a [i64]>>
) -> Tensor
pub fn internal_test_serialization_subcmul(&self, other: &Tensor) -> Tensor
pub fn internal_test_string_default(dummy: &Tensor, a: &str, b: &str) -> Tensor
pub fn internal_test_warn_in_autograd(&self) -> Tensor
pub fn internal_to_copy(
&self,
options: (Kind, Device),
non_blocking: bool
) -> Tensor
pub fn internal_to_cpu<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>
pub fn internal_torch_cuda_cu_linker_symbol_op(&self) -> Tensor
pub fn internal_trilinear(
i1: &Tensor,
i2: &Tensor,
i3: &Tensor,
expand1: &[i64],
expand2: &[i64],
expand3: &[i64],
sumdim: &[i64],
unroll_dim: i64
) -> Tensor
pub fn internal_unique(
&self,
sorted: bool,
return_inverse: bool
) -> (Tensor, Tensor)
pub fn internal_unique2(
&self,
sorted: bool,
return_inverse: bool,
return_counts: bool
) -> (Tensor, Tensor, Tensor)
pub fn internal_unpack_dual(dual: &Tensor, level: i64) -> (Tensor, Tensor)
pub fn internal_unsafe_view(&self, size: &[i64]) -> Tensor
pub fn internal_upsample_bicubic2d_aa(
&self,
output_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn internal_upsample_bicubic2d_aa_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn internal_upsample_bicubic2d_aa_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn internal_upsample_bicubic2d_aa_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
align_corners: bool,
scale_factors: &[f64]
) -> Tensor
pub fn internal_upsample_bicubic2d_aa_out(
&self,
out: &Tensor,
output_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn internal_upsample_bicubic2d_aa_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
align_corners: bool,
scale_factors: &[f64]
) -> Tensor
pub fn internal_upsample_bilinear2d_aa(
&self,
output_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn internal_upsample_bilinear2d_aa_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn internal_upsample_bilinear2d_aa_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn internal_upsample_bilinear2d_aa_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
align_corners: bool,
scale_factors: &[f64]
) -> Tensor
pub fn internal_upsample_bilinear2d_aa_out(
&self,
out: &Tensor,
output_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn internal_upsample_bilinear2d_aa_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
align_corners: bool,
scale_factors: &[f64]
) -> Tensor
pub fn internal_upsample_nearest_exact1d(
&self,
output_size: &[i64],
scales: impl Into<Option<f64>>
) -> Tensor
pub fn internal_upsample_nearest_exact1d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales: impl Into<Option<f64>>
) -> Tensor
pub fn internal_upsample_nearest_exact1d_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales: impl Into<Option<f64>>
) -> Tensor
pub fn internal_upsample_nearest_exact1d_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
scale_factors: &[f64]
) -> Tensor
pub fn internal_upsample_nearest_exact1d_out(
&self,
out: &Tensor,
output_size: &[i64],
scales: impl Into<Option<f64>>
) -> Tensor
pub fn internal_upsample_nearest_exact1d_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
scale_factors: &[f64]
) -> Tensor
pub fn internal_upsample_nearest_exact2d(
&self,
output_size: &[i64],
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn internal_upsample_nearest_exact2d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn internal_upsample_nearest_exact2d_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn internal_upsample_nearest_exact2d_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
scale_factors: &[f64]
) -> Tensor
pub fn internal_upsample_nearest_exact2d_out(
&self,
out: &Tensor,
output_size: &[i64],
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn internal_upsample_nearest_exact2d_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
scale_factors: &[f64]
) -> Tensor
pub fn internal_upsample_nearest_exact3d(
&self,
output_size: &[i64],
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn internal_upsample_nearest_exact3d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn internal_upsample_nearest_exact3d_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn internal_upsample_nearest_exact3d_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
scale_factors: &[f64]
) -> Tensor
pub fn internal_upsample_nearest_exact3d_out(
&self,
out: &Tensor,
output_size: &[i64],
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn internal_upsample_nearest_exact3d_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
scale_factors: &[f64]
) -> Tensor
pub fn internal_use_cudnn_ctc_loss(
log_probs: &Tensor,
targets: &Tensor,
input_lengths: &[i64],
target_lengths: &[i64],
blank: i64
) -> bool
pub fn internal_use_cudnn_rnn_flatten_weight() -> bool
pub fn internal_validate_sparse_csr_tensor_args(
crow_indices: &Tensor,
col_indices: &Tensor,
values: &Tensor,
size: &[i64]
)
pub fn internal_values(&self) -> Tensor
pub fn internal_version(&self) -> i64
pub fn internal_weight_norm(v: &Tensor, g: &Tensor, dim: i64) -> Tensor
pub fn internal_weight_norm_cuda_interface(
v: &Tensor,
g: &Tensor,
dim: i64
) -> (Tensor, Tensor)
pub fn internal_weight_norm_cuda_interface_backward(
grad_w: &Tensor,
saved_v: &Tensor,
saved_g: &Tensor,
saved_norms: &Tensor,
dim: i64
) -> (Tensor, Tensor)
pub fn internal_weight_norm_differentiable_backward(
grad_w: &Tensor,
saved_v: &Tensor,
saved_g: &Tensor,
saved_norms: &Tensor,
dim: i64
) -> (Tensor, Tensor)
pub fn abs(&self) -> Tensor
pub fn abs_(&mut self) -> Tensor
pub fn abs_out(&self, out: &Tensor) -> Tensor
pub fn absolute(&self) -> Tensor
pub fn absolute_(&mut self) -> Tensor
pub fn absolute_out(&self, out: &Tensor) -> Tensor
pub fn acos(&self) -> Tensor
pub fn acos_(&mut self) -> Tensor
pub fn acos_out(&self, out: &Tensor) -> Tensor
pub fn acosh(&self) -> Tensor
pub fn acosh_(&mut self) -> Tensor
pub fn acosh_out(&self, out: &Tensor) -> Tensor
pub fn adaptive_avg_pool1d(&self, output_size: &[i64]) -> Tensor
pub fn adaptive_avg_pool2d(&self, output_size: &[i64]) -> Tensor
pub fn adaptive_avg_pool2d_out(
&self,
out: &Tensor,
output_size: &[i64]
) -> Tensor
pub fn adaptive_avg_pool3d(&self, output_size: &[i64]) -> Tensor
pub fn adaptive_avg_pool3d_backward(
&self,
grad_input: &Tensor,
grad_output: &Tensor
) -> Tensor
pub fn adaptive_avg_pool3d_out(
&self,
out: &Tensor,
output_size: &[i64]
) -> Tensor
pub fn adaptive_max_pool1d(&self, output_size: &[i64]) -> (Tensor, Tensor)
pub fn adaptive_max_pool2d(&self, output_size: &[i64]) -> (Tensor, Tensor)
pub fn adaptive_max_pool2d_backward(
&self,
grad_output: &Tensor,
indices: &Tensor
) -> Tensor
pub fn adaptive_max_pool2d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor
) -> Tensor
pub fn adaptive_max_pool2d_out(
&self,
out: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> (Tensor, Tensor)
pub fn adaptive_max_pool3d(&self, output_size: &[i64]) -> (Tensor, Tensor)
pub fn adaptive_max_pool3d_backward(
&self,
grad_output: &Tensor,
indices: &Tensor
) -> Tensor
pub fn adaptive_max_pool3d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor
) -> Tensor
pub fn adaptive_max_pool3d_out(
&self,
out: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> (Tensor, Tensor)
pub fn g_add(&self, other: &Tensor) -> Tensor
pub fn g_add_(&mut self, other: &Tensor) -> Tensor
pub fn add_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn g_add_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn g_add_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn addbmm(&self, batch1: &Tensor, batch2: &Tensor) -> Tensor
pub fn addbmm_(&mut self, batch1: &Tensor, batch2: &Tensor) -> Tensor
pub fn addbmm_out(
&self,
out: &Tensor,
batch1: &Tensor,
batch2: &Tensor
) -> Tensor
pub fn addcdiv(&self, tensor1: &Tensor, tensor2: &Tensor) -> Tensor
pub fn addcdiv_(&mut self, tensor1: &Tensor, tensor2: &Tensor) -> Tensor
pub fn addcdiv_out(
&self,
out: &Tensor,
tensor1: &Tensor,
tensor2: &Tensor
) -> Tensor
pub fn addcmul(&self, tensor1: &Tensor, tensor2: &Tensor) -> Tensor
pub fn addcmul_(&mut self, tensor1: &Tensor, tensor2: &Tensor) -> Tensor
pub fn addcmul_out(
&self,
out: &Tensor,
tensor1: &Tensor,
tensor2: &Tensor
) -> Tensor
pub fn addmm(&self, mat1: &Tensor, mat2: &Tensor) -> Tensor
pub fn addmm_(&mut self, mat1: &Tensor, mat2: &Tensor) -> Tensor
pub fn addmm_out(&self, out: &Tensor, mat1: &Tensor, mat2: &Tensor) -> Tensor
pub fn addmv(&self, mat: &Tensor, vec: &Tensor) -> Tensor
pub fn addmv_(&mut self, mat: &Tensor, vec: &Tensor) -> Tensor
pub fn addmv_out(&self, out: &Tensor, mat: &Tensor, vec: &Tensor) -> Tensor
pub fn addr(&self, vec1: &Tensor, vec2: &Tensor) -> Tensor
pub fn addr_(&mut self, vec1: &Tensor, vec2: &Tensor) -> Tensor
pub fn addr_out(&self, out: &Tensor, vec1: &Tensor, vec2: &Tensor) -> Tensor
pub fn adjoint(&self) -> Tensor
pub fn affine_grid_generator(
theta: &Tensor,
size: &[i64],
align_corners: bool
) -> Tensor
pub fn affine_grid_generator_backward(
grad: &Tensor,
size: &[i64],
align_corners: bool
) -> Tensor
pub fn alias(&self) -> Tensor
pub fn align_as(&self, other: &Tensor) -> Tensor
pub fn align_tensors<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>
pub fn all(&self) -> Tensor
pub fn all_all_out(&self, out: &Tensor) -> Tensor
pub fn all_dim(&self, dim: i64, keepdim: bool) -> Tensor
pub fn all_out(&self, out: &Tensor, dim: i64, keepdim: bool) -> Tensor
pub fn allclose(
&self,
other: &Tensor,
rtol: f64,
atol: f64,
equal_nan: bool
) -> bool
pub fn alpha_dropout(&self, p: f64, train: bool) -> Tensor
pub fn alpha_dropout_(&mut self, p: f64, train: bool) -> Tensor
pub fn amax(&self, dim: &[i64], keepdim: bool) -> Tensor
pub fn amax_out(&self, out: &Tensor, dim: &[i64], keepdim: bool) -> Tensor
pub fn amin(&self, dim: &[i64], keepdim: bool) -> Tensor
pub fn amin_out(&self, out: &Tensor, dim: &[i64], keepdim: bool) -> Tensor
pub fn aminmax(
&self,
dim: impl Into<Option<i64>>,
keepdim: bool
) -> (Tensor, Tensor)
pub fn aminmax_out(
&self,
min: &Tensor,
max: &Tensor,
dim: impl Into<Option<i64>>,
keepdim: bool
) -> (Tensor, Tensor)
pub fn angle(&self) -> Tensor
pub fn angle_out(&self, out: &Tensor) -> Tensor
pub fn any(&self) -> Tensor
pub fn any_all_out(&self, out: &Tensor) -> Tensor
pub fn any_dim(&self, dim: i64, keepdim: bool) -> Tensor
pub fn any_out(&self, out: &Tensor, dim: i64, keepdim: bool) -> Tensor
pub fn arange<S: Into<Scalar>>(end: S, options: (Kind, Device)) -> Tensor
pub fn arange_out<S: Into<Scalar>>(out: &Tensor, end: S) -> Tensor
pub fn arange_start<S: Into<Scalar>>(
start: S,
end: S,
options: (Kind, Device)
) -> Tensor
pub fn arange_start_out<S: Into<Scalar>>(
out: &Tensor,
start: S,
end: S
) -> Tensor
pub fn arange_start_step<S: Into<Scalar>>(
start: S,
end: S,
step: S,
options: (Kind, Device)
) -> Tensor
pub fn arccos(&self) -> Tensor
pub fn arccos_(&mut self) -> Tensor
pub fn arccos_out(&self, out: &Tensor) -> Tensor
pub fn arccosh(&self) -> Tensor
pub fn arccosh_(&mut self) -> Tensor
pub fn arccosh_out(&self, out: &Tensor) -> Tensor
pub fn arcsin(&self) -> Tensor
pub fn arcsin_(&mut self) -> Tensor
pub fn arcsin_out(&self, out: &Tensor) -> Tensor
pub fn arcsinh(&self) -> Tensor
pub fn arcsinh_(&mut self) -> Tensor
pub fn arcsinh_out(&self, out: &Tensor) -> Tensor
pub fn arctan(&self) -> Tensor
pub fn arctan2(&self, other: &Tensor) -> Tensor
pub fn arctan2_(&mut self, other: &Tensor) -> Tensor
pub fn arctan2_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn arctan_(&mut self) -> Tensor
pub fn arctan_out(&self, out: &Tensor) -> Tensor
pub fn arctanh(&self) -> Tensor
pub fn arctanh_(&mut self) -> Tensor
pub fn arctanh_out(&self, out: &Tensor) -> Tensor
pub fn argmax(&self, dim: impl Into<Option<i64>>, keepdim: bool) -> Tensor
pub fn argmax_out(
&self,
out: &Tensor,
dim: impl Into<Option<i64>>,
keepdim: bool
) -> Tensor
pub fn argmin(&self, dim: impl Into<Option<i64>>, keepdim: bool) -> Tensor
pub fn argmin_out(
&self,
out: &Tensor,
dim: impl Into<Option<i64>>,
keepdim: bool
) -> Tensor
pub fn argsort(&self, dim: i64, descending: bool) -> Tensor
pub fn argwhere(&self) -> Tensor
pub fn as_strided(
&self,
size: &[i64],
stride: &[i64],
storage_offset: impl Into<Option<i64>>
) -> Tensor
pub fn as_strided_(
&mut self,
size: &[i64],
stride: &[i64],
storage_offset: impl Into<Option<i64>>
) -> Tensor
pub fn asin(&self) -> Tensor
pub fn asin_(&mut self) -> Tensor
pub fn asin_out(&self, out: &Tensor) -> Tensor
pub fn asinh(&self) -> Tensor
pub fn asinh_(&mut self) -> Tensor
pub fn asinh_out(&self, out: &Tensor) -> Tensor
pub fn atan(&self) -> Tensor
pub fn atan2(&self, other: &Tensor) -> Tensor
pub fn atan2_(&mut self, other: &Tensor) -> Tensor
pub fn atan2_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn atan_(&mut self) -> Tensor
pub fn atan_out(&self, out: &Tensor) -> Tensor
pub fn atanh(&self) -> Tensor
pub fn atanh_(&mut self) -> Tensor
pub fn atanh_out(&self, out: &Tensor) -> Tensor
pub fn atleast_1d(&self) -> Tensor
pub fn atleast_1d_sequence<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>
pub fn atleast_2d(&self) -> Tensor
pub fn atleast_2d_sequence<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>
pub fn atleast_3d(&self) -> Tensor
pub fn atleast_3d_sequence<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>
pub fn avg_pool1d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Tensor
pub fn avg_pool2d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool,
divisor_override: impl Into<Option<i64>>
) -> Tensor
pub fn avg_pool2d_backward(
&self,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool,
divisor_override: impl Into<Option<i64>>
) -> Tensor
pub fn avg_pool2d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool,
divisor_override: impl Into<Option<i64>>
) -> Tensor
pub fn avg_pool2d_out(
&self,
out: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool,
divisor_override: impl Into<Option<i64>>
) -> Tensor
pub fn avg_pool3d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool,
divisor_override: impl Into<Option<i64>>
) -> Tensor
pub fn avg_pool3d_backward(
&self,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool,
divisor_override: impl Into<Option<i64>>
) -> Tensor
pub fn avg_pool3d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool,
divisor_override: impl Into<Option<i64>>
) -> Tensor
pub fn avg_pool3d_out(
&self,
out: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool,
divisor_override: impl Into<Option<i64>>
) -> Tensor
pub fn baddbmm(&self, batch1: &Tensor, batch2: &Tensor) -> Tensor
pub fn baddbmm_(&mut self, batch1: &Tensor, batch2: &Tensor) -> Tensor
pub fn baddbmm_out(
&self,
out: &Tensor,
batch1: &Tensor,
batch2: &Tensor
) -> Tensor
pub fn bartlett_window(window_length: i64, options: (Kind, Device)) -> Tensor
pub fn bartlett_window_periodic(
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Tensor
pub fn batch_norm<T: Borrow<Tensor>>(
&self,
weight: Option<T>,
bias: Option<T>,
running_mean: Option<T>,
running_var: Option<T>,
training: bool,
momentum: f64,
eps: f64,
cudnn_enabled: bool
) -> Tensor
pub fn batch_norm_backward_elemt<T: Borrow<Tensor>>(
&self,
grad_out: &Tensor,
mean: &Tensor,
invstd: &Tensor,
weight: Option<T>,
mean_dy: &Tensor,
mean_dy_xmu: &Tensor,
count: &Tensor
) -> Tensor
pub fn batch_norm_backward_reduce<T: Borrow<Tensor>>(
&self,
grad_out: &Tensor,
mean: &Tensor,
invstd: &Tensor,
weight: Option<T>,
input_g: bool,
weight_g: bool,
bias_g: bool
) -> (Tensor, Tensor, Tensor, Tensor)
pub fn batch_norm_elemt<T: Borrow<Tensor>>(
&self,
weight: Option<T>,
bias: Option<T>,
mean: &Tensor,
invstd: &Tensor,
eps: f64
) -> Tensor
pub fn batch_norm_elemt_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
weight: Option<T>,
bias: Option<T>,
mean: &Tensor,
invstd: &Tensor,
eps: f64
) -> Tensor
pub fn batch_norm_gather_stats<T: Borrow<Tensor>>(
&self,
mean: &Tensor,
invstd: &Tensor,
running_mean: Option<T>,
running_var: Option<T>,
momentum: f64,
eps: f64,
count: i64
) -> (Tensor, Tensor)
pub fn batch_norm_gather_stats_with_counts<T: Borrow<Tensor>>(
&self,
mean: &Tensor,
invstd: &Tensor,
running_mean: Option<T>,
running_var: Option<T>,
momentum: f64,
eps: f64,
counts: &Tensor
) -> (Tensor, Tensor)
pub fn batch_norm_stats(&self, eps: f64) -> (Tensor, Tensor)
pub fn batch_norm_update_stats<T: Borrow<Tensor>>(
&self,
running_mean: Option<T>,
running_var: Option<T>,
momentum: f64
) -> (Tensor, Tensor)
pub fn bernoulli(&self) -> Tensor
pub fn bernoulli_(&mut self, p: &Tensor) -> Tensor
pub fn bernoulli_float_(&mut self, p: f64) -> Tensor
pub fn bernoulli_out(&self, out: &Tensor) -> Tensor
pub fn bernoulli_p(&self, p: f64) -> Tensor
pub fn bilinear<T: Borrow<Tensor>>(
input1: &Tensor,
input2: &Tensor,
weight: &Tensor,
bias: Option<T>
) -> Tensor
pub fn binary_cross_entropy<T: Borrow<Tensor>>(
&self,
target: &Tensor,
weight: Option<T>,
reduction: Reduction
) -> Tensor
pub fn binary_cross_entropy_backward<T: Borrow<Tensor>>(
&self,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: Reduction
) -> Tensor
pub fn binary_cross_entropy_backward_grad_input<T: Borrow<Tensor>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: Reduction
) -> Tensor
pub fn binary_cross_entropy_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: Reduction
) -> Tensor
pub fn binary_cross_entropy_with_logits<T: Borrow<Tensor>>(
&self,
target: &Tensor,
weight: Option<T>,
pos_weight: Option<T>,
reduction: Reduction
) -> Tensor
pub fn binary_cross_entropy_with_logits_backward<T: Borrow<Tensor>>(
&self,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
pos_weight: Option<T>,
reduction: Reduction
) -> Tensor
pub fn bincount<T: Borrow<Tensor>>(
&self,
weights: Option<T>,
minlength: i64
) -> Tensor
pub fn binomial(count: &Tensor, prob: &Tensor) -> Tensor
pub fn bitwise_and<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn bitwise_and_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn bitwise_and_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Tensor
pub fn bitwise_and_tensor(&self, other: &Tensor) -> Tensor
pub fn bitwise_and_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn bitwise_and_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn bitwise_left_shift(&self, other: &Tensor) -> Tensor
pub fn bitwise_left_shift_(&mut self, other: &Tensor) -> Tensor
pub fn bitwise_left_shift_scalar_tensor<S: Into<Scalar>>(
self_scalar: S,
other: &Tensor
) -> Tensor
pub fn bitwise_left_shift_tensor_out(
&self,
out: &Tensor,
other: &Tensor
) -> Tensor
pub fn bitwise_left_shift_tensor_scalar<S: Into<Scalar>>(
&self,
other: S
) -> Tensor
pub fn bitwise_left_shift_tensor_scalar_<S: Into<Scalar>>(
&mut self,
other: S
) -> Tensor
pub fn bitwise_left_shift_tensor_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Tensor
pub fn bitwise_not(&self) -> Tensor
pub fn bitwise_not_(&mut self) -> Tensor
pub fn bitwise_not_out(&self, out: &Tensor) -> Tensor
pub fn bitwise_or<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn bitwise_or_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn bitwise_or_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Tensor
pub fn bitwise_or_tensor(&self, other: &Tensor) -> Tensor
pub fn bitwise_or_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn bitwise_or_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn bitwise_right_shift(&self, other: &Tensor) -> Tensor
pub fn bitwise_right_shift_(&mut self, other: &Tensor) -> Tensor
pub fn bitwise_right_shift_scalar_tensor<S: Into<Scalar>>(
self_scalar: S,
other: &Tensor
) -> Tensor
pub fn bitwise_right_shift_tensor_out(
&self,
out: &Tensor,
other: &Tensor
) -> Tensor
pub fn bitwise_right_shift_tensor_scalar<S: Into<Scalar>>(
&self,
other: S
) -> Tensor
pub fn bitwise_right_shift_tensor_scalar_<S: Into<Scalar>>(
&mut self,
other: S
) -> Tensor
pub fn bitwise_right_shift_tensor_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Tensor
pub fn bitwise_xor<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn bitwise_xor_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn bitwise_xor_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Tensor
pub fn bitwise_xor_tensor(&self, other: &Tensor) -> Tensor
pub fn bitwise_xor_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn bitwise_xor_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn blackman_window(window_length: i64, options: (Kind, Device)) -> Tensor
pub fn blackman_window_periodic(
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Tensor
pub fn block_diag<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor
pub fn bmm(&self, mat2: &Tensor) -> Tensor
pub fn bmm_out(&self, out: &Tensor, mat2: &Tensor) -> Tensor
pub fn broadcast_tensors<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>
pub fn broadcast_to(&self, size: &[i64]) -> Tensor
pub fn bucketize(
&self,
boundaries: &Tensor,
out_int32: bool,
right: bool
) -> Tensor
pub fn bucketize_scalar<S: Into<Scalar>>(
self_scalar: S,
boundaries: &Tensor,
out_int32: bool,
right: bool
) -> Tensor
pub fn bucketize_tensor_out(
&self,
out: &Tensor,
boundaries: &Tensor,
out_int32: bool,
right: bool
) -> Tensor
pub fn can_cast(from: Kind, to: Kind) -> bool
pub fn cartesian_prod<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor
pub fn cat<T: Borrow<Tensor>>(tensors: &[T], dim: i64) -> Tensor
pub fn cat_out<T: Borrow<Tensor>>(
out: &Tensor,
tensors: &[T],
dim: i64
) -> Tensor
pub fn cauchy_(&mut self, median: f64, sigma: f64) -> Tensor
pub fn cdist(
x1: &Tensor,
x2: &Tensor,
p: f64,
compute_mode: impl Into<Option<i64>>
) -> Tensor
pub fn ceil(&self) -> Tensor
pub fn ceil_(&mut self) -> Tensor
pub fn ceil_out(&self, out: &Tensor) -> Tensor
pub fn celu(&self) -> Tensor
pub fn celu_(&mut self) -> Tensor
pub fn chain_matmul<T: Borrow<Tensor>>(matrices: &[T]) -> Tensor
pub fn chain_matmul_out<T: Borrow<Tensor>>(
out: &Tensor,
matrices: &[T]
) -> Tensor
pub fn channel_shuffle(&self, groups: i64) -> Tensor
pub fn cholesky(&self, upper: bool) -> Tensor
pub fn cholesky_inverse(&self, upper: bool) -> Tensor
pub fn cholesky_inverse_out(&self, out: &Tensor, upper: bool) -> Tensor
pub fn cholesky_out(&self, out: &Tensor, upper: bool) -> Tensor
pub fn cholesky_solve(&self, input2: &Tensor, upper: bool) -> Tensor
pub fn cholesky_solve_out(
&self,
out: &Tensor,
input2: &Tensor,
upper: bool
) -> Tensor
pub fn choose_qparams_optimized(
&self,
numel: i64,
n_bins: i64,
ratio: f64,
bit_width: i64
) -> (Tensor, Tensor)
pub fn chunk(&self, chunks: i64, dim: i64) -> Vec<Tensor>
pub fn clamp<S: Into<Scalar>>(&self, min: S, max: S) -> Tensor
pub fn clamp_<S: Into<Scalar>>(&mut self, min: S, max: S) -> Tensor
pub fn clamp_max<S: Into<Scalar>>(&self, max: S) -> Tensor
pub fn clamp_max_<S: Into<Scalar>>(&mut self, max: S) -> Tensor
pub fn clamp_max_out<S: Into<Scalar>>(&self, out: &Tensor, max: S) -> Tensor
pub fn clamp_max_tensor(&self, max: &Tensor) -> Tensor
pub fn clamp_max_tensor_(&mut self, max: &Tensor) -> Tensor
pub fn clamp_max_tensor_out(&self, out: &Tensor, max: &Tensor) -> Tensor
pub fn clamp_min<S: Into<Scalar>>(&self, min: S) -> Tensor
pub fn clamp_min_<S: Into<Scalar>>(&mut self, min: S) -> Tensor
pub fn clamp_min_out<S: Into<Scalar>>(&self, out: &Tensor, min: S) -> Tensor
pub fn clamp_min_tensor(&self, min: &Tensor) -> Tensor
pub fn clamp_min_tensor_(&mut self, min: &Tensor) -> Tensor
pub fn clamp_min_tensor_out(&self, out: &Tensor, min: &Tensor) -> Tensor
pub fn clamp_out<S: Into<Scalar>>(&self, out: &Tensor, min: S, max: S) -> Tensor
pub fn clamp_tensor<T: Borrow<Tensor>>(
&self,
min: Option<T>,
max: Option<T>
) -> Tensor
pub fn clamp_tensor_<T: Borrow<Tensor>>(
&mut self,
min: Option<T>,
max: Option<T>
) -> Tensor
pub fn clamp_tensor_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
min: Option<T>,
max: Option<T>
) -> Tensor
pub fn clip<S: Into<Scalar>>(&self, min: S, max: S) -> Tensor
pub fn clip_<S: Into<Scalar>>(&mut self, min: S, max: S) -> Tensor
pub fn clip_out<S: Into<Scalar>>(&self, out: &Tensor, min: S, max: S) -> Tensor
pub fn clip_tensor<T: Borrow<Tensor>>(
&self,
min: Option<T>,
max: Option<T>
) -> Tensor
pub fn clip_tensor_<T: Borrow<Tensor>>(
&mut self,
min: Option<T>,
max: Option<T>
) -> Tensor
pub fn clip_tensor_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
min: Option<T>,
max: Option<T>
) -> Tensor
pub fn coalesce(&self) -> Tensor
pub fn col2im(
&self,
output_size: &[i64],
kernel_size: &[i64],
dilation: &[i64],
padding: &[i64],
stride: &[i64]
) -> Tensor
pub fn col2im_backward(
grad_output: &Tensor,
kernel_size: &[i64],
dilation: &[i64],
padding: &[i64],
stride: &[i64]
) -> Tensor
pub fn col2im_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
dilation: &[i64],
padding: &[i64],
stride: &[i64]
) -> Tensor
pub fn col2im_out(
&self,
out: &Tensor,
output_size: &[i64],
kernel_size: &[i64],
dilation: &[i64],
padding: &[i64],
stride: &[i64]
) -> Tensor
pub fn col_indices(&self) -> Tensor
pub fn column_stack<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor
pub fn column_stack_out<T: Borrow<Tensor>>(
out: &Tensor,
tensors: &[T]
) -> Tensor
pub fn combinations(&self, r: i64, with_replacement: bool) -> Tensor
pub fn complex(real: &Tensor, imag: &Tensor) -> Tensor
pub fn complex_out(out: &Tensor, real: &Tensor, imag: &Tensor) -> Tensor
pub fn concat<T: Borrow<Tensor>>(tensors: &[T], dim: i64) -> Tensor
pub fn concat_out<T: Borrow<Tensor>>(
out: &Tensor,
tensors: &[T],
dim: i64
) -> Tensor
pub fn conj(&self) -> Tensor
pub fn conj_physical(&self) -> Tensor
pub fn conj_physical_(&mut self) -> Tensor
pub fn conj_physical_out(&self, out: &Tensor) -> Tensor
pub fn constant_pad_nd(&self, pad: &[i64]) -> Tensor
pub fn contiguous(&self) -> Tensor
pub fn conv1d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
groups: i64
) -> Tensor
pub fn conv1d_padding<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &str,
dilation: &[i64],
groups: i64
) -> Tensor
pub fn conv2d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
groups: i64
) -> Tensor
pub fn conv2d_padding<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &str,
dilation: &[i64],
groups: i64
) -> Tensor
pub fn conv3d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
groups: i64
) -> Tensor
pub fn conv3d_padding<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &str,
dilation: &[i64],
groups: i64
) -> Tensor
pub fn conv_depthwise3d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
kernel_size: &[i64],
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64]
) -> Tensor
pub fn conv_tbc(&self, weight: &Tensor, bias: &Tensor, pad: i64) -> Tensor
pub fn conv_tbc_backward(
&self,
input: &Tensor,
weight: &Tensor,
bias: &Tensor,
pad: i64
) -> (Tensor, Tensor, Tensor)
pub fn conv_transpose1d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
groups: i64,
dilation: &[i64]
) -> Tensor
pub fn conv_transpose2d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
groups: i64,
dilation: &[i64]
) -> Tensor
pub fn conv_transpose3d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
groups: i64,
dilation: &[i64]
) -> Tensor
pub fn convolution<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
transposed: bool,
output_padding: &[i64],
groups: i64
) -> Tensor
pub fn convolution_overrideable<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
transposed: bool,
output_padding: &[i64],
groups: i64
) -> Tensor
pub fn copy_sparse_to_sparse_(
&mut self,
src: &Tensor,
non_blocking: bool
) -> Tensor
pub fn copysign(&self, other: &Tensor) -> Tensor
pub fn copysign_(&mut self, other: &Tensor) -> Tensor
pub fn copysign_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn copysign_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn copysign_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn copysign_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Tensor
pub fn corrcoef(&self) -> Tensor
pub fn cos(&self) -> Tensor
pub fn cos_(&mut self) -> Tensor
pub fn cos_out(&self, out: &Tensor) -> Tensor
pub fn cosh(&self) -> Tensor
pub fn cosh_(&mut self) -> Tensor
pub fn cosh_out(&self, out: &Tensor) -> Tensor
pub fn cosine_embedding_loss(
input1: &Tensor,
input2: &Tensor,
target: &Tensor,
margin: f64,
reduction: Reduction
) -> Tensor
pub fn cosine_similarity(x1: &Tensor, x2: &Tensor, dim: i64, eps: f64) -> Tensor
pub fn count_nonzero(&self, dim: impl Into<Option<i64>>) -> Tensor
pub fn count_nonzero_dim_intlist(&self, dim: &[i64]) -> Tensor
pub fn cov<T: Borrow<Tensor>>(
&self,
correction: i64,
fweights: Option<T>,
aweights: Option<T>
) -> Tensor
pub fn cross(&self, other: &Tensor, dim: impl Into<Option<i64>>) -> Tensor
pub fn cross_entropy_loss<T: Borrow<Tensor>>(
&self,
target: &Tensor,
weight: Option<T>,
reduction: Reduction,
ignore_index: i64,
label_smoothing: f64
) -> Tensor
pub fn cross_out(
&self,
out: &Tensor,
other: &Tensor,
dim: impl Into<Option<i64>>
) -> Tensor
pub fn crow_indices(&self) -> Tensor
pub fn ctc_loss(
log_probs: &Tensor,
targets: &Tensor,
input_lengths: &[i64],
target_lengths: &[i64],
blank: i64,
reduction: Reduction,
zero_infinity: bool
) -> Tensor
pub fn ctc_loss_tensor(
log_probs: &Tensor,
targets: &Tensor,
input_lengths: &Tensor,
target_lengths: &Tensor,
blank: i64,
reduction: Reduction,
zero_infinity: bool
) -> Tensor
pub fn cudnn_affine_grid_generator(
theta: &Tensor,
n: i64,
c: i64,
h: i64,
w: i64
) -> Tensor
pub fn cudnn_affine_grid_generator_backward(
grad: &Tensor,
n: i64,
c: i64,
h: i64,
w: i64
) -> Tensor
pub fn cudnn_batch_norm<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
running_mean: Option<T>,
running_var: Option<T>,
training: bool,
exponential_average_factor: f64,
epsilon: f64
) -> (Tensor, Tensor, Tensor, Tensor)
pub fn cudnn_batch_norm_backward<T: Borrow<Tensor>>(
&self,
grad_output: &Tensor,
weight: &Tensor,
running_mean: Option<T>,
running_var: Option<T>,
save_mean: Option<T>,
save_var: Option<T>,
epsilon: f64,
reservespace: &Tensor
) -> (Tensor, Tensor, Tensor)
pub fn cudnn_convolution(
&self,
weight: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool,
allow_tf32: bool
) -> Tensor
pub fn cudnn_convolution_add_relu<T: Borrow<Tensor>, S: Into<Scalar>>(
&self,
weight: &Tensor,
z: &Tensor,
alpha: S,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
groups: i64
) -> Tensor
pub fn cudnn_convolution_relu<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
groups: i64
) -> Tensor
pub fn cudnn_convolution_transpose(
&self,
weight: &Tensor,
padding: &[i64],
output_padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool,
allow_tf32: bool
) -> Tensor
pub fn cudnn_grid_sampler(&self, grid: &Tensor) -> Tensor
pub fn cudnn_grid_sampler_backward(
&self,
grid: &Tensor,
grad_output: &Tensor
) -> (Tensor, Tensor)
pub fn cudnn_is_acceptable(&self) -> bool
pub fn cummax(&self, dim: i64) -> (Tensor, Tensor)
pub fn cummax_out(
&self,
values: &Tensor,
indices: &Tensor,
dim: i64
) -> (Tensor, Tensor)
pub fn cummaxmin_backward(
&self,
grad: &Tensor,
indices: &Tensor,
dim: i64
) -> Tensor
pub fn cummin(&self, dim: i64) -> (Tensor, Tensor)
pub fn cummin_out(
&self,
values: &Tensor,
indices: &Tensor,
dim: i64
) -> (Tensor, Tensor)
pub fn cumprod(&self, dim: i64, dtype: Kind) -> Tensor
pub fn cumprod_(&mut self, dim: i64, dtype: Kind) -> Tensor
pub fn cumprod_backward(
&self,
grad: &Tensor,
dim: i64,
output: &Tensor
) -> Tensor
pub fn cumprod_out(&self, out: &Tensor, dim: i64, dtype: Kind) -> Tensor
pub fn cumsum(&self, dim: i64, dtype: Kind) -> Tensor
pub fn cumsum_(&mut self, dim: i64, dtype: Kind) -> Tensor
pub fn cumsum_out(&self, out: &Tensor, dim: i64, dtype: Kind) -> Tensor
pub fn cumulative_trapezoid(y: &Tensor, dim: i64) -> Tensor
pub fn cumulative_trapezoid_x(y: &Tensor, x: &Tensor, dim: i64) -> Tensor
pub fn data(&self) -> Tensor
pub fn deg2rad(&self) -> Tensor
pub fn deg2rad_(&mut self) -> Tensor
pub fn deg2rad_out(&self, out: &Tensor) -> Tensor
pub fn dense_dim(&self) -> i64
pub fn dequantize(&self) -> Tensor
pub fn dequantize_tensors<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>
pub fn det(&self) -> Tensor
pub fn detach(&self) -> Tensor
pub fn detach_(&mut self) -> Tensor
pub fn diag(&self, diagonal: i64) -> Tensor
pub fn diag_backward(
grad: &Tensor,
input_sizes: &[i64],
diagonal: i64
) -> Tensor
pub fn diag_embed(&self, offset: i64, dim1: i64, dim2: i64) -> Tensor
pub fn diag_out(&self, out: &Tensor, diagonal: i64) -> Tensor
pub fn diagflat(&self, offset: i64) -> Tensor
pub fn diagonal(&self, offset: i64, dim1: i64, dim2: i64) -> Tensor
pub fn diagonal_backward(
grad_output: &Tensor,
input_sizes: &[i64],
offset: i64,
dim1: i64,
dim2: i64
) -> Tensor
pub fn diagonal_scatter(
&self,
src: &Tensor,
offset: i64,
dim1: i64,
dim2: i64
) -> Tensor
pub fn diff<T: Borrow<Tensor>>(
&self,
n: i64,
dim: i64,
prepend: Option<T>,
append: Option<T>
) -> Tensor
pub fn diff_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
n: i64,
dim: i64,
prepend: Option<T>,
append: Option<T>
) -> Tensor
pub fn digamma(&self) -> Tensor
pub fn digamma_(&mut self) -> Tensor
pub fn digamma_out(&self, out: &Tensor) -> Tensor
pub fn dist(&self, other: &Tensor) -> Tensor
pub fn g_div(&self, other: &Tensor) -> Tensor
pub fn g_div_(&mut self, other: &Tensor) -> Tensor
pub fn div_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn div_out_mode(
&self,
out: &Tensor,
other: &Tensor,
rounding_mode: &str
) -> Tensor
pub fn g_div_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn g_div_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn g_div_scalar_mode<S: Into<Scalar>>(
&self,
other: S,
rounding_mode: &str
) -> Tensor
pub fn g_div_scalar_mode_<S: Into<Scalar>>(
&mut self,
other: S,
rounding_mode: &str
) -> Tensor
pub fn g_div_tensor_mode(&self, other: &Tensor, rounding_mode: &str) -> Tensor
pub fn g_div_tensor_mode_(
&mut self,
other: &Tensor,
rounding_mode: &str
) -> Tensor
pub fn divide(&self, other: &Tensor) -> Tensor
pub fn divide_(&mut self, other: &Tensor) -> Tensor
pub fn divide_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn divide_out_mode(
&self,
out: &Tensor,
other: &Tensor,
rounding_mode: &str
) -> Tensor
pub fn divide_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn divide_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn divide_scalar_mode<S: Into<Scalar>>(
&self,
other: S,
rounding_mode: &str
) -> Tensor
pub fn divide_scalar_mode_<S: Into<Scalar>>(
&mut self,
other: S,
rounding_mode: &str
) -> Tensor
pub fn divide_tensor_mode(&self, other: &Tensor, rounding_mode: &str) -> Tensor
pub fn divide_tensor_mode_(
&mut self,
other: &Tensor,
rounding_mode: &str
) -> Tensor
pub fn dot(&self, tensor: &Tensor) -> Tensor
pub fn dot_out(&self, out: &Tensor, tensor: &Tensor) -> Tensor
pub fn dropout(&self, p: f64, train: bool) -> Tensor
pub fn dropout_(&mut self, p: f64, train: bool) -> Tensor
pub fn dsplit(&self, sections: i64) -> Vec<Tensor>
pub fn dsplit_array(&self, indices: &[i64]) -> Vec<Tensor>
pub fn dstack<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor
pub fn dstack_out<T: Borrow<Tensor>>(out: &Tensor, tensors: &[T]) -> Tensor
pub fn eig(&self, eigenvectors: bool) -> (Tensor, Tensor)
pub fn eig_e(
&self,
e: &Tensor,
v: &Tensor,
eigenvectors: bool
) -> (Tensor, Tensor)
pub fn einsum<T: Borrow<Tensor>>(equation: &str, tensors: &[T]) -> Tensor
pub fn elu(&self) -> Tensor
pub fn elu_(&mut self) -> Tensor
pub fn elu_backward<S: Into<Scalar>>(
grad_output: &Tensor,
alpha: S,
scale: S,
input_scale: S,
is_result: bool,
self_or_result: &Tensor
) -> Tensor
pub fn elu_backward_grad_input<S: Into<Scalar>>(
grad_input: &Tensor,
grad_output: &Tensor,
alpha: S,
scale: S,
input_scale: S,
is_result: bool,
self_or_result: &Tensor
) -> Tensor
pub fn elu_out(&self, out: &Tensor) -> Tensor
pub fn embedding(
weight: &Tensor,
indices: &Tensor,
padding_idx: i64,
scale_grad_by_freq: bool,
sparse: bool
) -> Tensor
pub fn embedding_backward(
grad: &Tensor,
indices: &Tensor,
num_weights: i64,
padding_idx: i64,
scale_grad_by_freq: bool,
sparse: bool
) -> Tensor
pub fn embedding_bag<T: Borrow<Tensor>>(
weight: &Tensor,
indices: &Tensor,
offsets: &Tensor,
scale_grad_by_freq: bool,
mode: i64,
sparse: bool,
per_sample_weights: Option<T>,
include_last_offset: bool
) -> (Tensor, Tensor, Tensor, Tensor)
pub fn embedding_bag_padding_idx<T: Borrow<Tensor>>(
weight: &Tensor,
indices: &Tensor,
offsets: &Tensor,
scale_grad_by_freq: bool,
mode: i64,
sparse: bool,
per_sample_weights: Option<T>,
include_last_offset: bool,
padding_idx: impl Into<Option<i64>>
) -> (Tensor, Tensor, Tensor, Tensor)
pub fn embedding_dense_backward(
grad_output: &Tensor,
indices: &Tensor,
num_weights: i64,
padding_idx: i64,
scale_grad_by_freq: bool
) -> Tensor
pub fn embedding_renorm_(
&mut self,
indices: &Tensor,
max_norm: f64,
norm_type: f64
) -> Tensor
pub fn embedding_sparse_backward(
grad: &Tensor,
indices: &Tensor,
num_weights: i64,
padding_idx: i64,
scale_grad_by_freq: bool
) -> Tensor
pub fn empty(size: &[i64], options: (Kind, Device)) -> Tensor
pub fn empty_like(&self) -> Tensor
pub fn empty_out(out: &Tensor, size: &[i64]) -> Tensor
pub fn empty_quantized(
size: &[i64],
qtensor: &Tensor,
options: (Kind, Device)
) -> Tensor
pub fn empty_strided(
size: &[i64],
stride: &[i64],
options: (Kind, Device)
) -> Tensor
pub fn eq<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn eq_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn eq_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor
pub fn eq_tensor(&self, other: &Tensor) -> Tensor
pub fn eq_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn eq_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn equal(&self, other: &Tensor) -> bool
pub fn erf(&self) -> Tensor
pub fn erf_(&mut self) -> Tensor
pub fn erf_out(&self, out: &Tensor) -> Tensor
pub fn erfc(&self) -> Tensor
pub fn erfc_(&mut self) -> Tensor
pub fn erfc_out(&self, out: &Tensor) -> Tensor
pub fn erfinv(&self) -> Tensor
pub fn erfinv_(&mut self) -> Tensor
pub fn erfinv_out(&self, out: &Tensor) -> Tensor
pub fn exp(&self) -> Tensor
pub fn exp2(&self) -> Tensor
pub fn exp2_(&mut self) -> Tensor
pub fn exp2_out(&self, out: &Tensor) -> Tensor
pub fn exp_(&mut self) -> Tensor
pub fn exp_out(&self, out: &Tensor) -> Tensor
pub fn expand(&self, size: &[i64], implicit: bool) -> Tensor
pub fn expand_as(&self, other: &Tensor) -> Tensor
pub fn expm1(&self) -> Tensor
pub fn expm1_(&mut self) -> Tensor
pub fn expm1_out(&self, out: &Tensor) -> Tensor
pub fn exponential_(&mut self, lambd: f64) -> Tensor
pub fn eye(n: i64, options: (Kind, Device)) -> Tensor
pub fn eye_m(n: i64, m: i64, options: (Kind, Device)) -> Tensor
pub fn eye_m_out(out: &Tensor, n: i64, m: i64) -> Tensor
pub fn eye_out(out: &Tensor, n: i64) -> Tensor
pub fn fake_quantize_per_channel_affine(
&self,
scale: &Tensor,
zero_point: &Tensor,
axis: i64,
quant_min: i64,
quant_max: i64
) -> Tensor
pub fn fake_quantize_per_channel_affine_cachemask(
&self,
scale: &Tensor,
zero_point: &Tensor,
axis: i64,
quant_min: i64,
quant_max: i64
) -> (Tensor, Tensor)
pub fn fake_quantize_per_channel_affine_cachemask_backward(
grad: &Tensor,
mask: &Tensor
) -> Tensor
pub fn fake_quantize_per_tensor_affine(
&self,
scale: f64,
zero_point: i64,
quant_min: i64,
quant_max: i64
) -> Tensor
pub fn fake_quantize_per_tensor_affine_cachemask(
&self,
scale: f64,
zero_point: i64,
quant_min: i64,
quant_max: i64
) -> (Tensor, Tensor)
pub fn fake_quantize_per_tensor_affine_cachemask_backward(
grad: &Tensor,
mask: &Tensor
) -> Tensor
pub fn fake_quantize_per_tensor_affine_tensor_qparams(
&self,
scale: &Tensor,
zero_point: &Tensor,
quant_min: i64,
quant_max: i64
) -> Tensor
pub fn fbgemm_linear_fp16_weight(
&self,
packed_weight: &Tensor,
bias: &Tensor
) -> Tensor
pub fn fbgemm_linear_fp16_weight_fp32_activation(
&self,
packed_weight: &Tensor,
bias: &Tensor
) -> Tensor
pub fn fbgemm_linear_int8_weight<S: Into<Scalar>>(
&self,
weight: &Tensor,
packed: &Tensor,
col_offsets: &Tensor,
weight_scale: S,
weight_zero_point: S,
bias: &Tensor
) -> Tensor
pub fn fbgemm_linear_int8_weight_fp32_activation<S: Into<Scalar>>(
&self,
weight: &Tensor,
packed: &Tensor,
col_offsets: &Tensor,
weight_scale: S,
weight_zero_point: S,
bias: &Tensor
) -> Tensor
pub fn fbgemm_pack_gemm_matrix_fp16(&self) -> Tensor
pub fn fbgemm_pack_quantized_matrix(&self) -> Tensor
pub fn fbgemm_pack_quantized_matrix_kn(&self, k: i64, n: i64) -> Tensor
pub fn feature_alpha_dropout(&self, p: f64, train: bool) -> Tensor
pub fn feature_alpha_dropout_(&mut self, p: f64, train: bool) -> Tensor
pub fn feature_dropout(&self, p: f64, train: bool) -> Tensor
pub fn feature_dropout_(&mut self, p: f64, train: bool) -> Tensor
pub fn fft_fft(&self, n: impl Into<Option<i64>>, dim: i64, norm: &str) -> Tensor
pub fn fft_fft2<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Tensor
pub fn fft_fft2_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Tensor
pub fn fft_fft_out(
&self,
out: &Tensor,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Tensor
pub fn fft_fftfreq(n: i64, d: f64, options: (Kind, Device)) -> Tensor
pub fn fft_fftfreq_out(out: &Tensor, n: i64, d: f64) -> Tensor
pub fn fft_fftn<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Tensor
pub fn fft_fftn_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Tensor
pub fn fft_fftshift<'a>(&self, dim: impl Into<Option<&'a [i64]>>) -> Tensor
pub fn fft_hfft(
&self,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Tensor
pub fn fft_hfft2<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Tensor
pub fn fft_hfft2_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Tensor
pub fn fft_hfft_out(
&self,
out: &Tensor,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Tensor
pub fn fft_hfftn<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Tensor
pub fn fft_hfftn_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Tensor
pub fn fft_ifft(
&self,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Tensor
pub fn fft_ifft2<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Tensor
pub fn fft_ifft2_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Tensor
pub fn fft_ifft_out(
&self,
out: &Tensor,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Tensor
pub fn fft_ifftn<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Tensor
pub fn fft_ifftn_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Tensor
pub fn fft_ifftshift<'a>(&self, dim: impl Into<Option<&'a [i64]>>) -> Tensor
pub fn fft_ihfft(
&self,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Tensor
pub fn fft_ihfft2<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Tensor
pub fn fft_ihfft2_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Tensor
pub fn fft_ihfft_out(
&self,
out: &Tensor,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Tensor
pub fn fft_ihfftn<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Tensor
pub fn fft_ihfftn_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Tensor
pub fn fft_irfft(
&self,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Tensor
pub fn fft_irfft2<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Tensor
pub fn fft_irfft2_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Tensor
pub fn fft_irfft_out(
&self,
out: &Tensor,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Tensor
pub fn fft_irfftn<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Tensor
pub fn fft_irfftn_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Tensor
pub fn fft_rfft(
&self,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Tensor
pub fn fft_rfft2<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Tensor
pub fn fft_rfft2_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: &[i64],
norm: &str
) -> Tensor
pub fn fft_rfft_out(
&self,
out: &Tensor,
n: impl Into<Option<i64>>,
dim: i64,
norm: &str
) -> Tensor
pub fn fft_rfftfreq(n: i64, d: f64, options: (Kind, Device)) -> Tensor
pub fn fft_rfftfreq_out(out: &Tensor, n: i64, d: f64) -> Tensor
pub fn fft_rfftn<'a>(
&self,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Tensor
pub fn fft_rfftn_out<'a>(
&self,
out: &Tensor,
s: impl Into<Option<&'a [i64]>>,
dim: impl Into<Option<&'a [i64]>>,
norm: &str
) -> Tensor
pub fn fill_<S: Into<Scalar>>(&mut self, value: S) -> Tensor
pub fn fill_diagonal_<S: Into<Scalar>>(
&mut self,
fill_value: S,
wrap: bool
) -> Tensor
pub fn fill_tensor_(&mut self, value: &Tensor) -> Tensor
pub fn fix(&self) -> Tensor
pub fn fix_(&mut self) -> Tensor
pub fn fix_out(&self, out: &Tensor) -> Tensor
pub fn flatten(&self, start_dim: i64, end_dim: i64) -> Tensor
pub fn flatten_dense_tensors<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor
pub fn flip(&self, dims: &[i64]) -> Tensor
pub fn fliplr(&self) -> Tensor
pub fn flipud(&self) -> Tensor
pub fn float_power(&self, exponent: &Tensor) -> Tensor
pub fn float_power_<S: Into<Scalar>>(&mut self, exponent: S) -> Tensor
pub fn float_power_scalar<S: Into<Scalar>>(
self_scalar: S,
exponent: &Tensor
) -> Tensor
pub fn float_power_scalar_out<S: Into<Scalar>>(
out: &Tensor,
self_scalar: S,
exponent: &Tensor
) -> Tensor
pub fn float_power_tensor_(&mut self, exponent: &Tensor) -> Tensor
pub fn float_power_tensor_scalar<S: Into<Scalar>>(&self, exponent: S) -> Tensor
pub fn float_power_tensor_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
exponent: S
) -> Tensor
pub fn float_power_tensor_tensor_out(
&self,
out: &Tensor,
exponent: &Tensor
) -> Tensor
pub fn floor(&self) -> Tensor
pub fn floor_(&mut self) -> Tensor
pub fn floor_divide(&self, other: &Tensor) -> Tensor
pub fn floor_divide_(&mut self, other: &Tensor) -> Tensor
pub fn floor_divide_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn floor_divide_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn floor_divide_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn floor_out(&self, out: &Tensor) -> Tensor
pub fn fmax(&self, other: &Tensor) -> Tensor
pub fn fmax_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn fmin(&self, other: &Tensor) -> Tensor
pub fn fmin_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn fmod<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn fmod_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn fmod_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor
pub fn fmod_tensor(&self, other: &Tensor) -> Tensor
pub fn fmod_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn fmod_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn frac(&self) -> Tensor
pub fn frac_(&mut self) -> Tensor
pub fn frac_out(&self, out: &Tensor) -> Tensor
pub fn fractional_max_pool2d(
&self,
kernel_size: &[i64],
output_size: &[i64],
random_samples: &Tensor
) -> (Tensor, Tensor)
pub fn fractional_max_pool2d_backward(
&self,
grad_output: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
indices: &Tensor
) -> Tensor
pub fn fractional_max_pool2d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
indices: &Tensor
) -> Tensor
pub fn fractional_max_pool2d_output(
&self,
output: &Tensor,
indices: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
random_samples: &Tensor
) -> (Tensor, Tensor)
pub fn fractional_max_pool3d(
&self,
kernel_size: &[i64],
output_size: &[i64],
random_samples: &Tensor
) -> (Tensor, Tensor)
pub fn fractional_max_pool3d_backward(
&self,
grad_output: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
indices: &Tensor
) -> Tensor
pub fn fractional_max_pool3d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
indices: &Tensor
) -> Tensor
pub fn fractional_max_pool3d_output(
&self,
output: &Tensor,
indices: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
random_samples: &Tensor
) -> (Tensor, Tensor)
pub fn frexp(&self) -> (Tensor, Tensor)
pub fn frexp_tensor_out(
&self,
mantissa: &Tensor,
exponent: &Tensor
) -> (Tensor, Tensor)
pub fn frobenius_norm(&self) -> Tensor
pub fn frobenius_norm_dim(&self, dim: &[i64], keepdim: bool) -> Tensor
pub fn frobenius_norm_out(
&self,
out: &Tensor,
dim: &[i64],
keepdim: bool
) -> Tensor
pub fn from_file(
filename: &str,
shared: bool,
size: impl Into<Option<i64>>,
options: (Kind, Device)
) -> Tensor
pub fn full<S: Into<Scalar>>(
size: &[i64],
fill_value: S,
options: (Kind, Device)
) -> Tensor
pub fn full_like<S: Into<Scalar>>(&self, fill_value: S) -> Tensor
pub fn full_out<S: Into<Scalar>>(
out: &Tensor,
size: &[i64],
fill_value: S
) -> Tensor
pub fn fused_moving_avg_obs_fake_quant(
&self,
observer_on: &Tensor,
fake_quant_on: &Tensor,
running_min: &Tensor,
running_max: &Tensor,
scale: &Tensor,
zero_point: &Tensor,
averaging_const: f64,
quant_min: i64,
quant_max: i64,
ch_axis: i64,
per_row_fake_quant: bool,
symmetric_quant: bool
) -> Tensor
pub fn gather(&self, dim: i64, index: &Tensor, sparse_grad: bool) -> Tensor
pub fn gather_backward(
&self,
grad: &Tensor,
dim: i64,
index: &Tensor,
sparse_grad: bool
) -> Tensor
pub fn gather_out(
&self,
out: &Tensor,
dim: i64,
index: &Tensor,
sparse_grad: bool
) -> Tensor
pub fn gcd(&self, other: &Tensor) -> Tensor
pub fn gcd_(&mut self, other: &Tensor) -> Tensor
pub fn gcd_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn ge<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn ge_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn ge_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor
pub fn ge_tensor(&self, other: &Tensor) -> Tensor
pub fn ge_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn ge_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn gelu(&self) -> Tensor
pub fn gelu_backward(&self, grad: &Tensor) -> Tensor
pub fn gelu_backward_grad_input(
&self,
grad_input: &Tensor,
grad: &Tensor
) -> Tensor
pub fn gelu_out(&self, out: &Tensor) -> Tensor
pub fn geometric_(&mut self, p: f64) -> Tensor
pub fn geqrf(&self) -> (Tensor, Tensor)
pub fn geqrf_a(&self, a: &Tensor, tau: &Tensor) -> (Tensor, Tensor)
pub fn ger(&self, vec2: &Tensor) -> Tensor
pub fn ger_out(&self, out: &Tensor, vec2: &Tensor) -> Tensor
pub fn glu(&self, dim: i64) -> Tensor
pub fn glu_backward(&self, grad_output: &Tensor, dim: i64) -> Tensor
pub fn glu_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
dim: i64
) -> Tensor
pub fn glu_out(&self, out: &Tensor, dim: i64) -> Tensor
pub fn grad(&self) -> Tensor
pub fn greater<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn greater_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn greater_equal<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn greater_equal_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn greater_equal_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Tensor
pub fn greater_equal_tensor(&self, other: &Tensor) -> Tensor
pub fn greater_equal_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn greater_equal_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn greater_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Tensor
pub fn greater_tensor(&self, other: &Tensor) -> Tensor
pub fn greater_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn greater_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn grid_sampler(
&self,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64,
align_corners: bool
) -> Tensor
pub fn grid_sampler_2d(
&self,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64,
align_corners: bool
) -> Tensor
pub fn grid_sampler_3d(
&self,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64,
align_corners: bool
) -> Tensor
pub fn grid_sampler_3d_backward(
&self,
grad_output: &Tensor,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64,
align_corners: bool
) -> (Tensor, Tensor)
pub fn group_norm<T: Borrow<Tensor>>(
&self,
num_groups: i64,
weight: Option<T>,
bias: Option<T>,
eps: f64,
cudnn_enabled: bool
) -> Tensor
pub fn gru<T: Borrow<Tensor>>(
&self,
hx: &Tensor,
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool,
batch_first: bool
) -> (Tensor, Tensor)
pub fn gru_cell<T: Borrow<Tensor>>(
&self,
hx: &Tensor,
w_ih: &Tensor,
w_hh: &Tensor,
b_ih: Option<T>,
b_hh: Option<T>
) -> Tensor
pub fn gru_data<T: Borrow<Tensor>>(
data: &Tensor,
batch_sizes: &Tensor,
hx: &Tensor,
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool
) -> (Tensor, Tensor)
pub fn gt<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn gt_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn gt_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor
pub fn gt_tensor(&self, other: &Tensor) -> Tensor
pub fn gt_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn gt_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn hamming_window(window_length: i64, options: (Kind, Device)) -> Tensor
pub fn hamming_window_periodic(
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Tensor
pub fn hamming_window_periodic_alpha(
window_length: i64,
periodic: bool,
alpha: f64,
options: (Kind, Device)
) -> Tensor
pub fn hamming_window_periodic_alpha_beta(
window_length: i64,
periodic: bool,
alpha: f64,
beta: f64,
options: (Kind, Device)
) -> Tensor
pub fn hann_window(window_length: i64, options: (Kind, Device)) -> Tensor
pub fn hann_window_periodic(
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Tensor
pub fn hardshrink(&self) -> Tensor
pub fn hardshrink_backward<S: Into<Scalar>>(
&self,
grad_out: &Tensor,
lambd: S
) -> Tensor
pub fn hardshrink_backward_grad_input<S: Into<Scalar>>(
&self,
grad_input: &Tensor,
grad_out: &Tensor,
lambd: S
) -> Tensor
pub fn hardshrink_out(&self, out: &Tensor) -> Tensor
pub fn hardsigmoid(&self) -> Tensor
pub fn hardsigmoid_(&mut self) -> Tensor
pub fn hardsigmoid_backward(&self, grad_output: &Tensor) -> Tensor
pub fn hardsigmoid_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor
) -> Tensor
pub fn hardsigmoid_out(&self, out: &Tensor) -> Tensor
pub fn hardswish(&self) -> Tensor
pub fn hardswish_(&mut self) -> Tensor
pub fn hardswish_backward(&self, grad_output: &Tensor) -> Tensor
pub fn hardswish_out(&self, out: &Tensor) -> Tensor
pub fn hardtanh(&self) -> Tensor
pub fn hardtanh_(&mut self) -> Tensor
pub fn hardtanh_backward<S: Into<Scalar>>(
&self,
grad_output: &Tensor,
min_val: S,
max_val: S
) -> Tensor
pub fn hardtanh_backward_grad_input<S: Into<Scalar>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
min_val: S,
max_val: S
) -> Tensor
pub fn hardtanh_out(&self, out: &Tensor) -> Tensor
pub fn heaviside(&self, values: &Tensor) -> Tensor
pub fn heaviside_(&mut self, values: &Tensor) -> Tensor
pub fn heaviside_out(&self, out: &Tensor, values: &Tensor) -> Tensor
pub fn hinge_embedding_loss(
&self,
target: &Tensor,
margin: f64,
reduction: Reduction
) -> Tensor
pub fn histc(&self, bins: i64) -> Tensor
pub fn histc_out(&self, out: &Tensor, bins: i64) -> Tensor
pub fn histogram<T: Borrow<Tensor>>(
&self,
bins: &Tensor,
weight: Option<T>,
density: bool
) -> (Tensor, Tensor)
pub fn histogram_bin_ct<T: Borrow<Tensor>>(
&self,
bins: i64,
range: &[f64],
weight: Option<T>,
density: bool
) -> (Tensor, Tensor)
pub fn histogram_bin_ct_out<T: Borrow<Tensor>>(
&self,
hist: &Tensor,
bin_edges: &Tensor,
bins: i64,
range: &[f64],
weight: Option<T>,
density: bool
) -> (Tensor, Tensor)
pub fn histogram_bins_tensor_out<T: Borrow<Tensor>>(
&self,
hist: &Tensor,
bin_edges: &Tensor,
bins: &Tensor,
weight: Option<T>,
density: bool
) -> (Tensor, Tensor)
pub fn hsplit(&self, sections: i64) -> Vec<Tensor>
pub fn hsplit_array(&self, indices: &[i64]) -> Vec<Tensor>
pub fn hspmm(mat1: &Tensor, mat2: &Tensor) -> Tensor
pub fn hspmm_out(out: &Tensor, mat1: &Tensor, mat2: &Tensor) -> Tensor
pub fn hstack<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor
pub fn hstack_out<T: Borrow<Tensor>>(out: &Tensor, tensors: &[T]) -> Tensor
pub fn huber_loss(
&self,
target: &Tensor,
reduction: Reduction,
delta: f64
) -> Tensor
pub fn huber_loss_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction,
delta: f64
) -> Tensor
pub fn huber_loss_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction,
delta: f64
) -> Tensor
pub fn huber_loss_out(
&self,
out: &Tensor,
target: &Tensor,
reduction: Reduction,
delta: f64
) -> Tensor
pub fn hypot(&self, other: &Tensor) -> Tensor
pub fn hypot_(&mut self, other: &Tensor) -> Tensor
pub fn hypot_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn i0(&self) -> Tensor
pub fn i0_(&mut self) -> Tensor
pub fn i0_out(&self, out: &Tensor) -> Tensor
pub fn igamma(&self, other: &Tensor) -> Tensor
pub fn igamma_(&mut self, other: &Tensor) -> Tensor
pub fn igamma_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn igammac(&self, other: &Tensor) -> Tensor
pub fn igammac_(&mut self, other: &Tensor) -> Tensor
pub fn igammac_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn im2col(
&self,
kernel_size: &[i64],
dilation: &[i64],
padding: &[i64],
stride: &[i64]
) -> Tensor
pub fn im2col_backward(
grad_output: &Tensor,
input_size: &[i64],
kernel_size: &[i64],
dilation: &[i64],
padding: &[i64],
stride: &[i64]
) -> Tensor
pub fn im2col_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
input_size: &[i64],
kernel_size: &[i64],
dilation: &[i64],
padding: &[i64],
stride: &[i64]
) -> Tensor
pub fn im2col_out(
&self,
out: &Tensor,
kernel_size: &[i64],
dilation: &[i64],
padding: &[i64],
stride: &[i64]
) -> Tensor
pub fn imag(&self) -> Tensor
pub fn index<T: Borrow<Tensor>>(&self, indices: &[Option<T>]) -> Tensor
pub fn index_add(&self, dim: i64, index: &Tensor, source: &Tensor) -> Tensor
pub fn index_add_(
&mut self,
dim: i64,
index: &Tensor,
source: &Tensor
) -> Tensor
pub fn index_add_out(
&self,
out: &Tensor,
dim: i64,
index: &Tensor,
source: &Tensor
) -> Tensor
pub fn index_copy(&self, dim: i64, index: &Tensor, source: &Tensor) -> Tensor
pub fn index_copy_(
&mut self,
dim: i64,
index: &Tensor,
source: &Tensor
) -> Tensor
pub fn index_fill<S: Into<Scalar>>(
&self,
dim: i64,
index: &Tensor,
value: S
) -> Tensor
pub fn index_fill_<S: Into<Scalar>>(
&mut self,
dim: i64,
index: &Tensor,
value: S
) -> Tensor
pub fn index_fill_int_tensor(
&self,
dim: i64,
index: &Tensor,
value: &Tensor
) -> Tensor
pub fn index_fill_int_tensor_(
&mut self,
dim: i64,
index: &Tensor,
value: &Tensor
) -> Tensor
pub fn index_put<T: Borrow<Tensor>>(
&self,
indices: &[Option<T>],
values: &Tensor,
accumulate: bool
) -> Tensor
pub fn index_put_<T: Borrow<Tensor>>(
&mut self,
indices: &[Option<T>],
values: &Tensor,
accumulate: bool
) -> Tensor
pub fn index_select(&self, dim: i64, index: &Tensor) -> Tensor
pub fn index_select_backward(
grad: &Tensor,
self_sizes: &[i64],
dim: i64,
index: &Tensor
) -> Tensor
pub fn index_select_out(&self, out: &Tensor, dim: i64, index: &Tensor) -> Tensor
pub fn indices(&self) -> Tensor
pub fn infinitely_differentiable_gelu_backward(&self, grad: &Tensor) -> Tensor
pub fn inner(&self, other: &Tensor) -> Tensor
pub fn inner_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn instance_norm<T: Borrow<Tensor>>(
&self,
weight: Option<T>,
bias: Option<T>,
running_mean: Option<T>,
running_var: Option<T>,
use_input_stats: bool,
momentum: f64,
eps: f64,
cudnn_enabled: bool
) -> Tensor
pub fn int_repr(&self) -> Tensor
pub fn inverse(&self) -> Tensor
pub fn inverse_out(&self, out: &Tensor) -> Tensor
pub fn is_coalesced(&self) -> bool
pub fn is_complex(&self) -> bool
pub fn is_conj(&self) -> bool
pub fn is_distributed(&self) -> bool
pub fn is_floating_point(&self) -> bool
pub fn is_inference(&self) -> bool
pub fn is_leaf(&self) -> bool
pub fn is_neg(&self) -> bool
pub fn is_nonzero(&self) -> bool
pub fn is_pinned(&self, device: Device) -> bool
pub fn is_same_size(&self, other: &Tensor) -> bool
pub fn is_set_to(&self, tensor: &Tensor) -> bool
pub fn is_signed(&self) -> bool
pub fn is_vulkan_available() -> bool
pub fn isclose(
&self,
other: &Tensor,
rtol: f64,
atol: f64,
equal_nan: bool
) -> Tensor
pub fn isfinite(&self) -> Tensor
pub fn isin(
elements: &Tensor,
test_elements: &Tensor,
assume_unique: bool,
invert: bool
) -> Tensor
pub fn isin_scalar_tensor<S: Into<Scalar>>(
element: S,
test_elements: &Tensor,
assume_unique: bool,
invert: bool
) -> Tensor
pub fn isin_scalar_tensor_out<S: Into<Scalar>>(
out: &Tensor,
element: S,
test_elements: &Tensor,
assume_unique: bool,
invert: bool
) -> Tensor
pub fn isin_tensor_scalar<S: Into<Scalar>>(
elements: &Tensor,
test_element: S,
assume_unique: bool,
invert: bool
) -> Tensor
pub fn isin_tensor_scalar_out<S: Into<Scalar>>(
out: &Tensor,
elements: &Tensor,
test_element: S,
assume_unique: bool,
invert: bool
) -> Tensor
pub fn isin_tensor_tensor_out(
out: &Tensor,
elements: &Tensor,
test_elements: &Tensor,
assume_unique: bool,
invert: bool
) -> Tensor
pub fn isinf(&self) -> Tensor
pub fn isnan(&self) -> Tensor
pub fn isneginf(&self) -> Tensor
pub fn isneginf_out(&self, out: &Tensor) -> Tensor
pub fn isposinf(&self) -> Tensor
pub fn isposinf_out(&self, out: &Tensor) -> Tensor
pub fn isreal(&self) -> Tensor
pub fn istft<T: Borrow<Tensor>>(
&self,
n_fft: i64,
hop_length: impl Into<Option<i64>>,
win_length: impl Into<Option<i64>>,
window: Option<T>,
center: bool,
normalized: bool,
onesided: bool,
length: impl Into<Option<i64>>,
return_complex: bool
) -> Tensor
pub fn kaiser_window(window_length: i64, options: (Kind, Device)) -> Tensor
pub fn kaiser_window_beta(
window_length: i64,
periodic: bool,
beta: f64,
options: (Kind, Device)
) -> Tensor
pub fn kaiser_window_periodic(
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Tensor
pub fn kl_div(
&self,
target: &Tensor,
reduction: Reduction,
log_target: bool
) -> Tensor
pub fn kl_div_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction,
log_target: bool
) -> Tensor
pub fn kron(&self, other: &Tensor) -> Tensor
pub fn kron_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn kthvalue(&self, k: i64, dim: i64, keepdim: bool) -> (Tensor, Tensor)
pub fn kthvalue_values(
&self,
values: &Tensor,
indices: &Tensor,
k: i64,
dim: i64,
keepdim: bool
) -> (Tensor, Tensor)
pub fn l1_loss(&self, target: &Tensor, reduction: Reduction) -> Tensor
pub fn l1_loss_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction
) -> Tensor
pub fn l1_loss_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction
) -> Tensor
pub fn l1_loss_out(
&self,
out: &Tensor,
target: &Tensor,
reduction: Reduction
) -> Tensor
pub fn layer_norm<T: Borrow<Tensor>>(
&self,
normalized_shape: &[i64],
weight: Option<T>,
bias: Option<T>,
eps: f64,
cudnn_enable: bool
) -> Tensor
pub fn lcm(&self, other: &Tensor) -> Tensor
pub fn lcm_(&mut self, other: &Tensor) -> Tensor
pub fn lcm_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn ldexp(&self, other: &Tensor) -> Tensor
pub fn ldexp_(&mut self, other: &Tensor) -> Tensor
pub fn ldexp_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn le<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn le_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn le_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor
pub fn le_tensor(&self, other: &Tensor) -> Tensor
pub fn le_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn le_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn leaky_relu(&self) -> Tensor
pub fn leaky_relu_(&mut self) -> Tensor
pub fn leaky_relu_backward<S: Into<Scalar>>(
&self,
grad_output: &Tensor,
negative_slope: S,
self_is_result: bool
) -> Tensor
pub fn leaky_relu_backward_grad_input<S: Into<Scalar>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
negative_slope: S,
self_is_result: bool
) -> Tensor
pub fn leaky_relu_out(&self, out: &Tensor) -> Tensor
pub fn lerp<S: Into<Scalar>>(&self, end: &Tensor, weight: S) -> Tensor
pub fn lerp_<S: Into<Scalar>>(&mut self, end: &Tensor, weight: S) -> Tensor
pub fn lerp_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
end: &Tensor,
weight: S
) -> Tensor
pub fn lerp_tensor(&self, end: &Tensor, weight: &Tensor) -> Tensor
pub fn lerp_tensor_(&mut self, end: &Tensor, weight: &Tensor) -> Tensor
pub fn lerp_tensor_out(
&self,
out: &Tensor,
end: &Tensor,
weight: &Tensor
) -> Tensor
pub fn less<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn less_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn less_equal<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn less_equal_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn less_equal_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Tensor
pub fn less_equal_tensor(&self, other: &Tensor) -> Tensor
pub fn less_equal_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn less_equal_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn less_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor
pub fn less_tensor(&self, other: &Tensor) -> Tensor
pub fn less_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn less_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn lgamma(&self) -> Tensor
pub fn lgamma_(&mut self) -> Tensor
pub fn lgamma_out(&self, out: &Tensor) -> Tensor
pub fn linalg_cholesky(&self, upper: bool) -> Tensor
pub fn linalg_cholesky_ex(
&self,
upper: bool,
check_errors: bool
) -> (Tensor, Tensor)
pub fn linalg_cholesky_ex_l(
&self,
l: &Tensor,
info: &Tensor,
upper: bool,
check_errors: bool
) -> (Tensor, Tensor)
pub fn linalg_cholesky_out(&self, out: &Tensor, upper: bool) -> Tensor
pub fn linalg_cond<S: Into<Scalar>>(&self, p: S) -> Tensor
pub fn linalg_cond_out<S: Into<Scalar>>(&self, out: &Tensor, p: S) -> Tensor
pub fn linalg_cond_p_str(&self, p: &str) -> Tensor
pub fn linalg_cond_p_str_out(&self, out: &Tensor, p: &str) -> Tensor
pub fn linalg_cross(&self, other: &Tensor, dim: i64) -> Tensor
pub fn linalg_cross_out(&self, out: &Tensor, other: &Tensor, dim: i64) -> Tensor
pub fn linalg_det(&self) -> Tensor
pub fn linalg_det_out(&self, out: &Tensor) -> Tensor
pub fn linalg_diagonal(a: &Tensor, offset: i64, dim1: i64, dim2: i64) -> Tensor
pub fn linalg_eig(&self) -> (Tensor, Tensor)
pub fn linalg_eig_out(
&self,
eigenvalues: &Tensor,
eigenvectors: &Tensor
) -> (Tensor, Tensor)
pub fn linalg_eigh(&self, uplo: &str) -> (Tensor, Tensor)
pub fn linalg_eigh_eigvals(
&self,
eigvals: &Tensor,
eigvecs: &Tensor,
uplo: &str
) -> (Tensor, Tensor)
pub fn linalg_eigvals(&self) -> Tensor
pub fn linalg_eigvals_out(&self, out: &Tensor) -> Tensor
pub fn linalg_eigvalsh(&self, uplo: &str) -> Tensor
pub fn linalg_eigvalsh_out(&self, out: &Tensor, uplo: &str) -> Tensor
pub fn linalg_householder_product(&self, tau: &Tensor) -> Tensor
pub fn linalg_householder_product_out(
&self,
out: &Tensor,
tau: &Tensor
) -> Tensor
pub fn linalg_inv(&self) -> Tensor
pub fn linalg_inv_ex(&self, check_errors: bool) -> (Tensor, Tensor)
pub fn linalg_inv_ex_inverse(
&self,
inverse: &Tensor,
info: &Tensor,
check_errors: bool
) -> (Tensor, Tensor)
pub fn linalg_inv_out(&self, out: &Tensor) -> Tensor
pub fn linalg_lstsq(
&self,
b: &Tensor,
rcond: impl Into<Option<f64>>,
driver: &str
) -> (Tensor, Tensor, Tensor, Tensor)
pub fn linalg_lstsq_out(
&self,
solution: &Tensor,
residuals: &Tensor,
rank: &Tensor,
singular_values: &Tensor,
b: &Tensor,
rcond: impl Into<Option<f64>>,
driver: &str
) -> (Tensor, Tensor, Tensor, Tensor)
pub fn linalg_lu_factor(a: &Tensor, pivot: bool) -> (Tensor, Tensor)
pub fn linalg_lu_factor_ex(
a: &Tensor,
pivot: bool,
check_errors: bool
) -> (Tensor, Tensor, Tensor)
pub fn linalg_lu_factor_ex_out(
lu: &Tensor,
pivots: &Tensor,
info: &Tensor,
a: &Tensor,
pivot: bool,
check_errors: bool
) -> (Tensor, Tensor, Tensor)
pub fn linalg_lu_factor_out(
lu: &Tensor,
pivots: &Tensor,
a: &Tensor,
pivot: bool
) -> (Tensor, Tensor)
pub fn linalg_matmul(&self, other: &Tensor) -> Tensor
pub fn linalg_matmul_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn linalg_matrix_exp(&self) -> Tensor
pub fn linalg_matrix_power(&self, n: i64) -> Tensor
pub fn linalg_matrix_power_out(&self, out: &Tensor, n: i64) -> Tensor
pub fn linalg_matrix_rank(&self, tol: f64, hermitian: bool) -> Tensor
pub fn linalg_matrix_rank_atol_rtol_float(
&self,
atol: impl Into<Option<f64>>,
rtol: impl Into<Option<f64>>,
hermitian: bool
) -> Tensor
pub fn linalg_matrix_rank_atol_rtol_float_out(
&self,
out: &Tensor,
atol: impl Into<Option<f64>>,
rtol: impl Into<Option<f64>>,
hermitian: bool
) -> Tensor
pub fn linalg_matrix_rank_atol_rtol_tensor<T: Borrow<Tensor>>(
&self,
atol: Option<T>,
rtol: Option<T>,
hermitian: bool
) -> Tensor
pub fn linalg_matrix_rank_atol_rtol_tensor_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
atol: Option<T>,
rtol: Option<T>,
hermitian: bool
) -> Tensor
pub fn linalg_matrix_rank_out(
&self,
out: &Tensor,
tol: f64,
hermitian: bool
) -> Tensor
pub fn linalg_matrix_rank_out_tol_tensor(
&self,
out: &Tensor,
tol: &Tensor,
hermitian: bool
) -> Tensor
pub fn linalg_matrix_rank_tol_tensor(
&self,
tol: &Tensor,
hermitian: bool
) -> Tensor
pub fn linalg_multi_dot<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor
pub fn linalg_multi_dot_out<T: Borrow<Tensor>>(
out: &Tensor,
tensors: &[T]
) -> Tensor
pub fn linalg_norm<'a, S: Into<Scalar>>(
&self,
ord: S,
dim: impl Into<Option<&'a [i64]>>,
keepdim: bool,
dtype: Kind
) -> Tensor
pub fn linalg_norm_ord_str<'a>(
&self,
ord: &str,
dim: impl Into<Option<&'a [i64]>>,
keepdim: bool,
dtype: Kind
) -> Tensor
pub fn linalg_norm_ord_str_out<'a>(
&self,
out: &Tensor,
ord: &str,
dim: impl Into<Option<&'a [i64]>>,
keepdim: bool,
dtype: Kind
) -> Tensor
pub fn linalg_norm_out<'a, S: Into<Scalar>>(
&self,
out: &Tensor,
ord: S,
dim: impl Into<Option<&'a [i64]>>,
keepdim: bool,
dtype: Kind
) -> Tensor
pub fn linalg_pinv(&self, rcond: f64, hermitian: bool) -> Tensor
pub fn linalg_pinv_atol_rtol_float(
&self,
atol: impl Into<Option<f64>>,
rtol: impl Into<Option<f64>>,
hermitian: bool
) -> Tensor
pub fn linalg_pinv_atol_rtol_float_out(
&self,
out: &Tensor,
atol: impl Into<Option<f64>>,
rtol: impl Into<Option<f64>>,
hermitian: bool
) -> Tensor
pub fn linalg_pinv_atol_rtol_tensor<T: Borrow<Tensor>>(
&self,
atol: Option<T>,
rtol: Option<T>,
hermitian: bool
) -> Tensor
pub fn linalg_pinv_atol_rtol_tensor_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
atol: Option<T>,
rtol: Option<T>,
hermitian: bool
) -> Tensor
pub fn linalg_pinv_out(
&self,
out: &Tensor,
rcond: f64,
hermitian: bool
) -> Tensor
pub fn linalg_pinv_out_rcond_tensor(
&self,
out: &Tensor,
rcond: &Tensor,
hermitian: bool
) -> Tensor
pub fn linalg_pinv_rcond_tensor(
&self,
rcond: &Tensor,
hermitian: bool
) -> Tensor
pub fn linalg_qr(&self, mode: &str) -> (Tensor, Tensor)
pub fn linalg_qr_out(
&self,
q: &Tensor,
r: &Tensor,
mode: &str
) -> (Tensor, Tensor)
pub fn linalg_slogdet(&self) -> (Tensor, Tensor)
pub fn linalg_slogdet_out(
&self,
sign: &Tensor,
logabsdet: &Tensor
) -> (Tensor, Tensor)
pub fn linalg_solve(&self, other: &Tensor) -> Tensor
pub fn linalg_solve_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn linalg_solve_triangular(
&self,
b: &Tensor,
upper: bool,
left: bool,
unitriangular: bool
) -> Tensor
pub fn linalg_solve_triangular_out(
&self,
out: &Tensor,
b: &Tensor,
upper: bool,
left: bool,
unitriangular: bool
) -> Tensor
pub fn linalg_svd(a: &Tensor, full_matrices: bool) -> (Tensor, Tensor, Tensor)
pub fn linalg_svd_u(
u: &Tensor,
s: &Tensor,
vh: &Tensor,
a: &Tensor,
full_matrices: bool
) -> (Tensor, Tensor, Tensor)
pub fn linalg_svdvals(a: &Tensor) -> Tensor
pub fn linalg_svdvals_out(out: &Tensor, a: &Tensor) -> Tensor
pub fn linalg_tensorinv(&self, ind: i64) -> Tensor
pub fn linalg_tensorinv_out(&self, out: &Tensor, ind: i64) -> Tensor
pub fn linalg_tensorsolve<'a>(
&self,
other: &Tensor,
dims: impl Into<Option<&'a [i64]>>
) -> Tensor
pub fn linalg_tensorsolve_out<'a>(
&self,
out: &Tensor,
other: &Tensor,
dims: impl Into<Option<&'a [i64]>>
) -> Tensor
pub fn linear<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>
) -> Tensor
pub fn linear_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
weight: &Tensor,
bias: Option<T>
) -> Tensor
pub fn linspace<S: Into<Scalar>>(
start: S,
end: S,
steps: i64,
options: (Kind, Device)
) -> Tensor
pub fn linspace_out<S: Into<Scalar>>(
out: &Tensor,
start: S,
end: S,
steps: i64
) -> Tensor
pub fn log(&self) -> Tensor
pub fn log10(&self) -> Tensor
pub fn log10_(&mut self) -> Tensor
pub fn log10_out(&self, out: &Tensor) -> Tensor
pub fn log1p(&self) -> Tensor
pub fn log1p_(&mut self) -> Tensor
pub fn log1p_out(&self, out: &Tensor) -> Tensor
pub fn log2(&self) -> Tensor
pub fn log2_(&mut self) -> Tensor
pub fn log2_out(&self, out: &Tensor) -> Tensor
pub fn log_(&mut self) -> Tensor
pub fn log_normal_(&mut self, mean: f64, std: f64) -> Tensor
pub fn log_out(&self, out: &Tensor) -> Tensor
pub fn log_sigmoid(&self) -> Tensor
pub fn log_sigmoid_backward(
&self,
grad_output: &Tensor,
buffer: &Tensor
) -> Tensor
pub fn log_sigmoid_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
buffer: &Tensor
) -> Tensor
pub fn log_sigmoid_out(&self, out: &Tensor) -> Tensor
pub fn log_softmax(&self, dim: i64, dtype: Kind) -> Tensor
pub fn logaddexp(&self, other: &Tensor) -> Tensor
pub fn logaddexp2(&self, other: &Tensor) -> Tensor
pub fn logaddexp2_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn logaddexp_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn logcumsumexp(&self, dim: i64) -> Tensor
pub fn logcumsumexp_out(&self, out: &Tensor, dim: i64) -> Tensor
pub fn logdet(&self) -> Tensor
pub fn logical_and(&self, other: &Tensor) -> Tensor
pub fn logical_and_(&mut self, other: &Tensor) -> Tensor
pub fn logical_and_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn logical_not(&self) -> Tensor
pub fn logical_not_(&mut self) -> Tensor
pub fn logical_not_out(&self, out: &Tensor) -> Tensor
pub fn logical_or(&self, other: &Tensor) -> Tensor
pub fn logical_or_(&mut self, other: &Tensor) -> Tensor
pub fn logical_or_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn logical_xor(&self, other: &Tensor) -> Tensor
pub fn logical_xor_(&mut self, other: &Tensor) -> Tensor
pub fn logical_xor_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn logit(&self, eps: impl Into<Option<f64>>) -> Tensor
pub fn logit_(&mut self, eps: impl Into<Option<f64>>) -> Tensor
pub fn logit_backward(
&self,
grad_output: &Tensor,
eps: impl Into<Option<f64>>
) -> Tensor
pub fn logit_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
eps: impl Into<Option<f64>>
) -> Tensor
pub fn logit_out(&self, out: &Tensor, eps: impl Into<Option<f64>>) -> Tensor
pub fn logspace<S: Into<Scalar>>(
start: S,
end: S,
steps: i64,
base: f64,
options: (Kind, Device)
) -> Tensor
pub fn logspace_out<S: Into<Scalar>>(
out: &Tensor,
start: S,
end: S,
steps: i64,
base: f64
) -> Tensor
pub fn logsumexp(&self, dim: &[i64], keepdim: bool) -> Tensor
pub fn logsumexp_out(&self, out: &Tensor, dim: &[i64], keepdim: bool) -> Tensor
pub fn lstm<T: Borrow<Tensor>>(
&self,
hx: &[T],
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool,
batch_first: bool
) -> (Tensor, Tensor, Tensor)
pub fn lstm_cell<T: Borrow<Tensor>>(
&self,
hx: &[T],
w_ih: &Tensor,
w_hh: &Tensor,
b_ih: Option<T>,
b_hh: Option<T>
) -> (Tensor, Tensor)
pub fn lstm_data<T: Borrow<Tensor>>(
data: &Tensor,
batch_sizes: &Tensor,
hx: &[T],
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool
) -> (Tensor, Tensor, Tensor)
pub fn lstsq(&self, a: &Tensor) -> (Tensor, Tensor)
pub fn lstsq_x(&self, x: &Tensor, qr: &Tensor, a: &Tensor) -> (Tensor, Tensor)
pub fn lt<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn lt_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn lt_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor
pub fn lt_tensor(&self, other: &Tensor) -> Tensor
pub fn lt_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn lt_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn lu_solve(&self, lu_data: &Tensor, lu_pivots: &Tensor) -> Tensor
pub fn lu_solve_out(
&self,
out: &Tensor,
lu_data: &Tensor,
lu_pivots: &Tensor
) -> Tensor
pub fn lu_unpack(
lu_data: &Tensor,
lu_pivots: &Tensor,
unpack_data: bool,
unpack_pivots: bool
) -> (Tensor, Tensor, Tensor)
pub fn lu_unpack_out(
p: &Tensor,
l: &Tensor,
u: &Tensor,
lu_data: &Tensor,
lu_pivots: &Tensor,
unpack_data: bool,
unpack_pivots: bool
) -> (Tensor, Tensor, Tensor)
pub fn margin_ranking_loss(
input1: &Tensor,
input2: &Tensor,
target: &Tensor,
margin: f64,
reduction: Reduction
) -> Tensor
pub fn masked_fill<S: Into<Scalar>>(&self, mask: &Tensor, value: S) -> Tensor
pub fn masked_fill_<S: Into<Scalar>>(
&mut self,
mask: &Tensor,
value: S
) -> Tensor
pub fn masked_fill_tensor(&self, mask: &Tensor, value: &Tensor) -> Tensor
pub fn masked_fill_tensor_(&mut self, mask: &Tensor, value: &Tensor) -> Tensor
pub fn masked_scatter(&self, mask: &Tensor, source: &Tensor) -> Tensor
pub fn masked_scatter_(&mut self, mask: &Tensor, source: &Tensor) -> Tensor
pub fn masked_select(&self, mask: &Tensor) -> Tensor
pub fn masked_select_backward(&self, grad: &Tensor, mask: &Tensor) -> Tensor
pub fn masked_select_out(&self, out: &Tensor, mask: &Tensor) -> Tensor
pub fn matmul(&self, other: &Tensor) -> Tensor
pub fn matmul_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn matrix_exp(&self) -> Tensor
pub fn matrix_exp_backward(&self, grad: &Tensor) -> Tensor
pub fn matrix_h(&self) -> Tensor
pub fn matrix_power(&self, n: i64) -> Tensor
pub fn matrix_power_out(&self, out: &Tensor, n: i64) -> Tensor
pub fn matrix_rank(&self, symmetric: bool) -> Tensor
pub fn matrix_rank_tol(&self, tol: f64, symmetric: bool) -> Tensor
pub fn max(&self) -> Tensor
pub fn max_dim(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)
pub fn max_dim_max(
&self,
max: &Tensor,
max_values: &Tensor,
dim: i64,
keepdim: bool
) -> (Tensor, Tensor)
pub fn max_other(&self, other: &Tensor) -> Tensor
pub fn max_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn max_pool1d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Tensor
pub fn max_pool1d_with_indices(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> (Tensor, Tensor)
pub fn max_pool2d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Tensor
pub fn max_pool2d_with_indices(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> (Tensor, Tensor)
pub fn max_pool2d_with_indices_backward(
&self,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool,
indices: &Tensor
) -> Tensor
pub fn max_pool2d_with_indices_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool,
indices: &Tensor
) -> Tensor
pub fn max_pool2d_with_indices_out(
&self,
out: &Tensor,
indices: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> (Tensor, Tensor)
pub fn max_pool3d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Tensor
pub fn max_pool3d_with_indices(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> (Tensor, Tensor)
pub fn max_pool3d_with_indices_backward(
&self,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool,
indices: &Tensor
) -> Tensor
pub fn max_pool3d_with_indices_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool,
indices: &Tensor
) -> Tensor
pub fn max_pool3d_with_indices_out(
&self,
out: &Tensor,
indices: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> (Tensor, Tensor)
pub fn max_unpool2d(&self, indices: &Tensor, output_size: &[i64]) -> Tensor
pub fn max_unpool2d_backward(
&self,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Tensor
pub fn max_unpool2d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Tensor
pub fn max_unpool2d_out(
&self,
out: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Tensor
pub fn max_unpool3d(
&self,
indices: &Tensor,
output_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Tensor
pub fn max_unpool3d_backward(
&self,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Tensor
pub fn max_unpool3d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Tensor
pub fn max_unpool3d_out(
&self,
out: &Tensor,
indices: &Tensor,
output_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Tensor
pub fn maximum(&self, other: &Tensor) -> Tensor
pub fn maximum_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn mean(&self, dtype: Kind) -> Tensor
pub fn mean_dim(&self, dim: &[i64], keepdim: bool, dtype: Kind) -> Tensor
pub fn mean_out(
&self,
out: &Tensor,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Tensor
pub fn median(&self) -> Tensor
pub fn median_dim(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)
pub fn median_dim_values(
&self,
values: &Tensor,
indices: &Tensor,
dim: i64,
keepdim: bool
) -> (Tensor, Tensor)
pub fn meshgrid<T: Borrow<Tensor>>(tensors: &[T]) -> Vec<Tensor>
pub fn meshgrid_indexing<T: Borrow<Tensor>>(
tensors: &[T],
indexing: &str
) -> Vec<Tensor>
pub fn mh(&self) -> Tensor
pub fn min(&self) -> Tensor
pub fn min_dim(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)
pub fn min_dim_min(
&self,
min: &Tensor,
min_indices: &Tensor,
dim: i64,
keepdim: bool
) -> (Tensor, Tensor)
pub fn min_other(&self, other: &Tensor) -> Tensor
pub fn min_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn minimum(&self, other: &Tensor) -> Tensor
pub fn minimum_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn miopen_batch_norm<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
running_mean: Option<T>,
running_var: Option<T>,
training: bool,
exponential_average_factor: f64,
epsilon: f64
) -> (Tensor, Tensor, Tensor)
pub fn miopen_batch_norm_backward<T: Borrow<Tensor>>(
&self,
grad_output: &Tensor,
weight: &Tensor,
running_mean: Option<T>,
running_var: Option<T>,
save_mean: Option<T>,
save_var: Option<T>,
epsilon: f64
) -> (Tensor, Tensor, Tensor)
pub fn miopen_convolution<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Tensor
pub fn miopen_convolution_transpose<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
output_padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Tensor
pub fn miopen_depthwise_convolution<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Tensor
pub fn miopen_rnn<T: Borrow<Tensor>>(
&self,
weight: &[T],
weight_stride0: i64,
hx: &Tensor,
cx: Option<T>,
mode: i64,
hidden_size: i64,
num_layers: i64,
batch_first: bool,
dropout: f64,
train: bool,
bidirectional: bool,
batch_sizes: &[i64],
dropout_state: Option<T>
) -> (Tensor, Tensor, Tensor, Tensor, Tensor)
pub fn mish(&self) -> Tensor
pub fn mish_(&mut self) -> Tensor
pub fn mish_backward(&self, grad_output: &Tensor) -> Tensor
pub fn mish_out(&self, out: &Tensor) -> Tensor
pub fn mkldnn_adaptive_avg_pool2d(&self, output_size: &[i64]) -> Tensor
pub fn mkldnn_adaptive_avg_pool2d_backward(
&self,
grad_output: &Tensor
) -> Tensor
pub fn mkldnn_convolution<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64
) -> Tensor
pub fn mkldnn_linear<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>
) -> Tensor
pub fn mkldnn_linear_backward_input(
input_size: &[i64],
grad_output: &Tensor,
weight: &Tensor
) -> Tensor
pub fn mkldnn_linear_backward_weights(
&self,
grad_output: &Tensor,
weight: &Tensor,
bias_defined: bool
) -> (Tensor, Tensor)
pub fn mkldnn_max_pool2d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Tensor
pub fn mkldnn_max_pool2d_backward(
&self,
grad_output: &Tensor,
output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Tensor
pub fn mkldnn_max_pool3d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Tensor
pub fn mkldnn_max_pool3d_backward(
&self,
grad_output: &Tensor,
output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Tensor
pub fn mkldnn_reorder_conv2d_weight(
&self,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64
) -> Tensor
pub fn mkldnn_reorder_conv3d_weight(
&self,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64
) -> Tensor
pub fn mm(&self, mat2: &Tensor) -> Tensor
pub fn mm_out(&self, out: &Tensor, mat2: &Tensor) -> Tensor
pub fn mode(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)
pub fn mode_values(
&self,
values: &Tensor,
indices: &Tensor,
dim: i64,
keepdim: bool
) -> (Tensor, Tensor)
pub fn moveaxis(&self, source: &[i64], destination: &[i64]) -> Tensor
pub fn moveaxis_int(&self, source: i64, destination: i64) -> Tensor
pub fn movedim(&self, source: &[i64], destination: &[i64]) -> Tensor
pub fn movedim_int(&self, source: i64, destination: i64) -> Tensor
pub fn mse_loss(&self, target: &Tensor, reduction: Reduction) -> Tensor
pub fn mse_loss_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction
) -> Tensor
pub fn mse_loss_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction
) -> Tensor
pub fn mse_loss_out(
&self,
out: &Tensor,
target: &Tensor,
reduction: Reduction
) -> Tensor
pub fn msort(&self) -> Tensor
pub fn msort_out(&self, out: &Tensor) -> Tensor
pub fn mt(&self) -> Tensor
pub fn g_mul(&self, other: &Tensor) -> Tensor
pub fn g_mul_(&mut self, other: &Tensor) -> Tensor
pub fn mul_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn g_mul_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn g_mul_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn multi_margin_loss_backward<T: Borrow<Tensor>, S: Into<Scalar>>(
&self,
grad_output: &Tensor,
target: &Tensor,
p: S,
margin: S,
weight: Option<T>,
reduction: Reduction
) -> Tensor
pub fn multi_margin_loss_backward_grad_input<T: Borrow<Tensor>, S: Into<Scalar>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
p: S,
margin: S,
weight: Option<T>,
reduction: Reduction
) -> Tensor
pub fn multilabel_margin_loss(
&self,
target: &Tensor,
reduction: Reduction
) -> Tensor
pub fn multilabel_margin_loss_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction,
is_target: &Tensor
) -> Tensor
pub fn multilabel_margin_loss_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction,
is_target: &Tensor
) -> Tensor
pub fn multilabel_margin_loss_out(
&self,
out: &Tensor,
target: &Tensor,
reduction: Reduction
) -> Tensor
pub fn multinomial(&self, num_samples: i64, replacement: bool) -> Tensor
pub fn multinomial_out(
&self,
out: &Tensor,
num_samples: i64,
replacement: bool
) -> Tensor
pub fn multiply(&self, other: &Tensor) -> Tensor
pub fn multiply_(&mut self, other: &Tensor) -> Tensor
pub fn multiply_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn multiply_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn multiply_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn mv(&self, vec: &Tensor) -> Tensor
pub fn mv_out(&self, out: &Tensor, vec: &Tensor) -> Tensor
pub fn mvlgamma(&self, p: i64) -> Tensor
pub fn mvlgamma_(&mut self, p: i64) -> Tensor
pub fn mvlgamma_out(&self, out: &Tensor, p: i64) -> Tensor
pub fn nan_to_num(
&self,
nan: impl Into<Option<f64>>,
posinf: impl Into<Option<f64>>,
neginf: impl Into<Option<f64>>
) -> Tensor
pub fn nan_to_num_(
&mut self,
nan: impl Into<Option<f64>>,
posinf: impl Into<Option<f64>>,
neginf: impl Into<Option<f64>>
) -> Tensor
pub fn nan_to_num_out(
&self,
out: &Tensor,
nan: impl Into<Option<f64>>,
posinf: impl Into<Option<f64>>,
neginf: impl Into<Option<f64>>
) -> Tensor
pub fn nanmean(&self, dim: &[i64], keepdim: bool, dtype: Kind) -> Tensor
pub fn nanmean_out(
&self,
out: &Tensor,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Tensor
pub fn nanmedian(&self) -> Tensor
pub fn nanmedian_dim(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)
pub fn nanmedian_dim_values(
&self,
values: &Tensor,
indices: &Tensor,
dim: i64,
keepdim: bool
) -> (Tensor, Tensor)
pub fn nanquantile(
&self,
q: &Tensor,
dim: impl Into<Option<i64>>,
keepdim: bool,
interpolation: &str
) -> Tensor
pub fn nanquantile_out(
&self,
out: &Tensor,
q: &Tensor,
dim: impl Into<Option<i64>>,
keepdim: bool,
interpolation: &str
) -> Tensor
pub fn nanquantile_scalar(
&self,
q: f64,
dim: impl Into<Option<i64>>,
keepdim: bool,
interpolation: &str
) -> Tensor
pub fn nanquantile_scalar_out(
&self,
out: &Tensor,
q: f64,
dim: impl Into<Option<i64>>,
keepdim: bool,
interpolation: &str
) -> Tensor
pub fn nansum(&self, dtype: Kind) -> Tensor
pub fn nansum_dim_intlist(
&self,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Tensor
pub fn nansum_intlist_out(
&self,
out: &Tensor,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Tensor
pub fn narrow(&self, dim: i64, start: i64, length: i64) -> Tensor
pub fn narrow_copy(&self, dim: i64, start: i64, length: i64) -> Tensor
pub fn narrow_copy_out(
&self,
out: &Tensor,
dim: i64,
start: i64,
length: i64
) -> Tensor
pub fn narrow_tensor(&self, dim: i64, start: &Tensor, length: i64) -> Tensor
pub fn native_batch_norm<T: Borrow<Tensor>>(
&self,
weight: Option<T>,
bias: Option<T>,
running_mean: Option<T>,
running_var: Option<T>,
training: bool,
momentum: f64,
eps: f64
) -> (Tensor, Tensor, Tensor)
pub fn native_batch_norm_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
save_mean: &Tensor,
save_invstd: &Tensor,
weight: Option<T>,
bias: Option<T>,
running_mean: Option<T>,
running_var: Option<T>,
training: bool,
momentum: f64,
eps: f64
) -> (Tensor, Tensor, Tensor)
pub fn native_channel_shuffle(&self, groups: i64) -> Tensor
pub fn native_dropout(&self, p: f64, train: bool) -> (Tensor, Tensor)
pub fn native_dropout_backward(
grad_output: &Tensor,
mask: &Tensor,
scale: f64
) -> Tensor
pub fn native_group_norm<T: Borrow<Tensor>>(
&self,
weight: Option<T>,
bias: Option<T>,
n: i64,
c: i64,
hxw: i64,
group: i64,
eps: f64
) -> (Tensor, Tensor, Tensor)
pub fn native_layer_norm<T: Borrow<Tensor>>(
&self,
normalized_shape: &[i64],
weight: Option<T>,
bias: Option<T>,
eps: f64
) -> (Tensor, Tensor, Tensor)
pub fn native_norm(&self) -> Tensor
pub fn native_norm_scalaropt_dim_dtype<S: Into<Scalar>>(
&self,
p: S,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Tensor
pub fn ne<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn ne_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn ne_scalar_out<S: Into<Scalar>>(&self, out: &Tensor, other: S) -> Tensor
pub fn ne_tensor(&self, other: &Tensor) -> Tensor
pub fn ne_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn ne_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn neg(&self) -> Tensor
pub fn neg_(&mut self) -> Tensor
pub fn neg_out(&self, out: &Tensor) -> Tensor
pub fn negative(&self) -> Tensor
pub fn negative_(&mut self) -> Tensor
pub fn negative_out(&self, out: &Tensor) -> Tensor
pub fn new_empty(&self, size: &[i64], options: (Kind, Device)) -> Tensor
pub fn new_empty_strided(
&self,
size: &[i64],
stride: &[i64],
options: (Kind, Device)
) -> Tensor
pub fn new_full<S: Into<Scalar>>(
&self,
size: &[i64],
fill_value: S,
options: (Kind, Device)
) -> Tensor
pub fn new_ones(&self, size: &[i64], options: (Kind, Device)) -> Tensor
pub fn new_zeros(&self, size: &[i64], options: (Kind, Device)) -> Tensor
pub fn nextafter(&self, other: &Tensor) -> Tensor
pub fn nextafter_(&mut self, other: &Tensor) -> Tensor
pub fn nextafter_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn g_nll_loss<T: Borrow<Tensor>>(
&self,
target: &Tensor,
weight: Option<T>,
reduction: Reduction,
ignore_index: i64
) -> Tensor
pub fn nll_loss2d<T: Borrow<Tensor>>(
&self,
target: &Tensor,
weight: Option<T>,
reduction: Reduction,
ignore_index: i64
) -> Tensor
pub fn nll_loss2d_backward<T: Borrow<Tensor>>(
&self,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: Reduction,
ignore_index: i64,
total_weight: &Tensor
) -> Tensor
pub fn nll_loss2d_backward_grad_input<T: Borrow<Tensor>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: Reduction,
ignore_index: i64,
total_weight: &Tensor
) -> Tensor
pub fn nll_loss2d_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: Reduction,
ignore_index: i64
) -> Tensor
pub fn nll_loss_backward<T: Borrow<Tensor>>(
&self,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: Reduction,
ignore_index: i64,
total_weight: &Tensor
) -> Tensor
pub fn nll_loss_backward_grad_input<T: Borrow<Tensor>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: Reduction,
ignore_index: i64,
total_weight: &Tensor
) -> Tensor
pub fn nll_loss_nd<T: Borrow<Tensor>>(
&self,
target: &Tensor,
weight: Option<T>,
reduction: Reduction,
ignore_index: i64
) -> Tensor
pub fn nll_loss_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: Reduction,
ignore_index: i64
) -> Tensor
pub fn nonzero(&self) -> Tensor
pub fn nonzero_numpy(&self) -> Vec<Tensor>
pub fn nonzero_out(&self, out: &Tensor) -> Tensor
pub fn norm(&self) -> Tensor
pub fn norm_dtype_out<S: Into<Scalar>>(
&self,
out: &Tensor,
p: S,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Tensor
pub fn norm_except_dim(v: &Tensor, pow: i64, dim: i64) -> Tensor
pub fn norm_out<S: Into<Scalar>>(
&self,
out: &Tensor,
p: S,
dim: &[i64],
keepdim: bool
) -> Tensor
pub fn norm_scalaropt_dim<S: Into<Scalar>>(
&self,
p: S,
dim: &[i64],
keepdim: bool
) -> Tensor
pub fn norm_scalaropt_dim_dtype<S: Into<Scalar>>(
&self,
p: S,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Tensor
pub fn norm_scalaropt_dtype<S: Into<Scalar>>(&self, p: S, dtype: Kind) -> Tensor
pub fn normal(out: &Tensor, mean: &Tensor, std: f64) -> Tensor
pub fn normal_(&mut self, mean: f64, std: f64) -> Tensor
pub fn normal_float_float_out(
out: &Tensor,
mean: f64,
std: f64,
size: &[i64]
) -> Tensor
pub fn normal_float_tensor_out(out: &Tensor, mean: f64, std: &Tensor) -> Tensor
pub fn normal_tensor_tensor_out(
out: &Tensor,
mean: &Tensor,
std: &Tensor
) -> Tensor
pub fn not_equal<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn not_equal_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn not_equal_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Tensor
pub fn not_equal_tensor(&self, other: &Tensor) -> Tensor
pub fn not_equal_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn not_equal_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn nuclear_norm(&self, keepdim: bool) -> Tensor
pub fn nuclear_norm_dim(&self, dim: &[i64], keepdim: bool) -> Tensor
pub fn nuclear_norm_dim_out(
&self,
out: &Tensor,
dim: &[i64],
keepdim: bool
) -> Tensor
pub fn nuclear_norm_out(&self, out: &Tensor, keepdim: bool) -> Tensor
pub fn numpy_t(&self) -> Tensor
pub fn one_hot(&self, num_classes: i64) -> Tensor
pub fn ones(size: &[i64], options: (Kind, Device)) -> Tensor
pub fn ones_like(&self) -> Tensor
pub fn ones_out(out: &Tensor, size: &[i64]) -> Tensor
pub fn orgqr(&self, input2: &Tensor) -> Tensor
pub fn orgqr_out(&self, out: &Tensor, input2: &Tensor) -> Tensor
pub fn ormqr(
&self,
input2: &Tensor,
input3: &Tensor,
left: bool,
transpose: bool
) -> Tensor
pub fn ormqr_out(
&self,
out: &Tensor,
input2: &Tensor,
input3: &Tensor,
left: bool,
transpose: bool
) -> Tensor
pub fn outer(&self, vec2: &Tensor) -> Tensor
pub fn outer_out(&self, out: &Tensor, vec2: &Tensor) -> Tensor
pub fn output_nr(&self) -> i64
pub fn pad_sequence<T: Borrow<Tensor>>(
sequences: &[T],
batch_first: bool,
padding_value: f64
) -> Tensor
pub fn pairwise_distance(
x1: &Tensor,
x2: &Tensor,
p: f64,
eps: f64,
keepdim: bool
) -> Tensor
pub fn pdist(&self, p: f64) -> Tensor
pub fn permute(&self, dims: &[i64]) -> Tensor
pub fn pin_memory(&self, device: Device) -> Tensor
pub fn pinverse(&self, rcond: f64) -> Tensor
pub fn pixel_shuffle(&self, upscale_factor: i64) -> Tensor
pub fn pixel_unshuffle(&self, downscale_factor: i64) -> Tensor
pub fn poisson(&self) -> Tensor
pub fn poisson_nll_loss(
&self,
target: &Tensor,
log_input: bool,
full: bool,
eps: f64,
reduction: Reduction
) -> Tensor
pub fn polar(abs: &Tensor, angle: &Tensor) -> Tensor
pub fn polar_out(out: &Tensor, abs: &Tensor, angle: &Tensor) -> Tensor
pub fn polygamma(&self, n: i64) -> Tensor
pub fn polygamma_(&mut self, n: i64) -> Tensor
pub fn polygamma_out(&self, out: &Tensor, n: i64) -> Tensor
pub fn positive(&self) -> Tensor
pub fn pow(&self, exponent: &Tensor) -> Tensor
pub fn pow_<S: Into<Scalar>>(&mut self, exponent: S) -> Tensor
pub fn pow_scalar<S: Into<Scalar>>(self_scalar: S, exponent: &Tensor) -> Tensor
pub fn pow_scalar_out<S: Into<Scalar>>(
out: &Tensor,
self_scalar: S,
exponent: &Tensor
) -> Tensor
pub fn pow_tensor_(&mut self, exponent: &Tensor) -> Tensor
pub fn pow_tensor_scalar<S: Into<Scalar>>(&self, exponent: S) -> Tensor
pub fn pow_tensor_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
exponent: S
) -> Tensor
pub fn pow_tensor_tensor_out(&self, out: &Tensor, exponent: &Tensor) -> Tensor
pub fn prelu(&self, weight: &Tensor) -> Tensor
pub fn prelu_backward(
&self,
grad_output: &Tensor,
weight: &Tensor
) -> (Tensor, Tensor)
pub fn prod(&self, dtype: Kind) -> Tensor
pub fn prod_dim_int(&self, dim: i64, keepdim: bool, dtype: Kind) -> Tensor
pub fn prod_int_out(
&self,
out: &Tensor,
dim: i64,
keepdim: bool,
dtype: Kind
) -> Tensor
pub fn put(&self, index: &Tensor, source: &Tensor, accumulate: bool) -> Tensor
pub fn put_(
&mut self,
index: &Tensor,
source: &Tensor,
accumulate: bool
) -> Tensor
pub fn q_per_channel_axis(&self) -> i64
pub fn q_per_channel_scales(&self) -> Tensor
pub fn q_per_channel_zero_points(&self) -> Tensor
pub fn q_scale(&self) -> f64
pub fn q_zero_point(&self) -> i64
pub fn qr(&self, some: bool) -> (Tensor, Tensor)
pub fn qr_q(&self, q: &Tensor, r: &Tensor, some: bool) -> (Tensor, Tensor)
pub fn quantile(
&self,
q: &Tensor,
dim: impl Into<Option<i64>>,
keepdim: bool,
interpolation: &str
) -> Tensor
pub fn quantile_out(
&self,
out: &Tensor,
q: &Tensor,
dim: impl Into<Option<i64>>,
keepdim: bool,
interpolation: &str
) -> Tensor
pub fn quantile_scalar(
&self,
q: f64,
dim: impl Into<Option<i64>>,
keepdim: bool,
interpolation: &str
) -> Tensor
pub fn quantile_scalar_out(
&self,
out: &Tensor,
q: f64,
dim: impl Into<Option<i64>>,
keepdim: bool,
interpolation: &str
) -> Tensor
pub fn quantize_per_channel(
&self,
scales: &Tensor,
zero_points: &Tensor,
axis: i64,
dtype: Kind
) -> Tensor
pub fn quantize_per_tensor(
&self,
scale: f64,
zero_point: i64,
dtype: Kind
) -> Tensor
pub fn quantize_per_tensor_dynamic(
&self,
dtype: Kind,
reduce_range: bool
) -> Tensor
pub fn quantize_per_tensor_tensor_qparams(
&self,
scale: &Tensor,
zero_point: &Tensor,
dtype: Kind
) -> Tensor
pub fn quantize_per_tensor_tensors<T: Borrow<Tensor>>(
tensors: &[T],
scales: &Tensor,
zero_points: &Tensor,
dtype: Kind
) -> Vec<Tensor>
pub fn quantized_batch_norm<T: Borrow<Tensor>>(
&self,
weight: Option<T>,
bias: Option<T>,
mean: &Tensor,
var: &Tensor,
eps: f64,
output_scale: f64,
output_zero_point: i64
) -> Tensor
pub fn quantized_gru_cell<S: Into<Scalar>>(
&self,
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: S,
scale_hh: S,
zero_point_ih: S,
zero_point_hh: S
) -> Tensor
pub fn quantized_lstm_cell<T: Borrow<Tensor>, S: Into<Scalar>>(
&self,
hx: &[T],
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: S,
scale_hh: S,
zero_point_ih: S,
zero_point_hh: S
) -> (Tensor, Tensor)
pub fn quantized_max_pool1d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Tensor
pub fn quantized_max_pool2d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Tensor
pub fn quantized_rnn_relu_cell<S: Into<Scalar>>(
&self,
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: S,
scale_hh: S,
zero_point_ih: S,
zero_point_hh: S
) -> Tensor
pub fn quantized_rnn_tanh_cell<S: Into<Scalar>>(
&self,
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: S,
scale_hh: S,
zero_point_ih: S,
zero_point_hh: S
) -> Tensor
pub fn rad2deg(&self) -> Tensor
pub fn rad2deg_(&mut self) -> Tensor
pub fn rad2deg_out(&self, out: &Tensor) -> Tensor
pub fn rand(size: &[i64], options: (Kind, Device)) -> Tensor
pub fn rand_like(&self) -> Tensor
pub fn rand_out(out: &Tensor, size: &[i64]) -> Tensor
pub fn randint(high: i64, size: &[i64], options: (Kind, Device)) -> Tensor
pub fn randint_like(&self, high: i64) -> Tensor
pub fn randint_like_low_dtype(&self, low: i64, high: i64) -> Tensor
pub fn randint_low(
low: i64,
high: i64,
size: &[i64],
options: (Kind, Device)
) -> Tensor
pub fn randint_low_out(
out: &Tensor,
low: i64,
high: i64,
size: &[i64]
) -> Tensor
pub fn randint_out(out: &Tensor, high: i64, size: &[i64]) -> Tensor
pub fn randn(size: &[i64], options: (Kind, Device)) -> Tensor
pub fn randn_like(&self) -> Tensor
pub fn randn_out(out: &Tensor, size: &[i64]) -> Tensor
pub fn random_(&mut self) -> Tensor
pub fn random_from_(&mut self, from: i64, to: impl Into<Option<i64>>) -> Tensor
pub fn random_to_(&mut self, to: i64) -> Tensor
pub fn randperm(n: i64, options: (Kind, Device)) -> Tensor
pub fn randperm_out(out: &Tensor, n: i64) -> Tensor
pub fn range<S: Into<Scalar>>(
start: S,
end: S,
options: (Kind, Device)
) -> Tensor
pub fn range_out<S: Into<Scalar>>(out: &Tensor, start: S, end: S) -> Tensor
pub fn range_step<S: Into<Scalar>>(
start: S,
end: S,
options: (Kind, Device)
) -> Tensor
pub fn ravel(&self) -> Tensor
pub fn real(&self) -> Tensor
pub fn reciprocal(&self) -> Tensor
pub fn reciprocal_(&mut self) -> Tensor
pub fn reciprocal_out(&self, out: &Tensor) -> Tensor
pub fn reflection_pad1d(&self, padding: &[i64]) -> Tensor
pub fn reflection_pad1d_backward(
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
pub fn reflection_pad1d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
pub fn reflection_pad1d_out(&self, out: &Tensor, padding: &[i64]) -> Tensor
pub fn reflection_pad2d(&self, padding: &[i64]) -> Tensor
pub fn reflection_pad2d_backward(
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
pub fn reflection_pad2d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
pub fn reflection_pad2d_out(&self, out: &Tensor, padding: &[i64]) -> Tensor
pub fn reflection_pad3d(&self, padding: &[i64]) -> Tensor
pub fn reflection_pad3d_backward(
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
pub fn reflection_pad3d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
pub fn reflection_pad3d_out(&self, out: &Tensor, padding: &[i64]) -> Tensor
pub fn relu(&self) -> Tensor
pub fn relu6(&self) -> Tensor
pub fn relu6_(&mut self) -> Tensor
pub fn relu_(&mut self) -> Tensor
pub fn remainder<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn remainder_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn remainder_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Tensor
pub fn remainder_scalar_tensor<S: Into<Scalar>>(
self_scalar: S,
other: &Tensor
) -> Tensor
pub fn remainder_tensor(&self, other: &Tensor) -> Tensor
pub fn remainder_tensor_(&mut self, other: &Tensor) -> Tensor
pub fn remainder_tensor_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn renorm<S: Into<Scalar>>(&self, p: S, dim: i64, maxnorm: S) -> Tensor
pub fn renorm_<S: Into<Scalar>>(&mut self, p: S, dim: i64, maxnorm: S) -> Tensor
pub fn renorm_out<S: Into<Scalar>>(
&self,
out: &Tensor,
p: S,
dim: i64,
maxnorm: S
) -> Tensor
pub fn repeat(&self, repeats: &[i64]) -> Tensor
pub fn repeat_interleave(
repeats: &Tensor,
output_size: impl Into<Option<i64>>
) -> Tensor
pub fn repeat_interleave_self_int(
&self,
repeats: i64,
dim: impl Into<Option<i64>>,
output_size: impl Into<Option<i64>>
) -> Tensor
pub fn repeat_interleave_self_tensor(
&self,
repeats: &Tensor,
dim: impl Into<Option<i64>>,
output_size: impl Into<Option<i64>>
) -> Tensor
pub fn replication_pad1d(&self, padding: &[i64]) -> Tensor
pub fn replication_pad1d_backward(
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
pub fn replication_pad1d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
pub fn replication_pad1d_out(&self, out: &Tensor, padding: &[i64]) -> Tensor
pub fn replication_pad2d(&self, padding: &[i64]) -> Tensor
pub fn replication_pad2d_backward(
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
pub fn replication_pad2d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
pub fn replication_pad2d_out(&self, out: &Tensor, padding: &[i64]) -> Tensor
pub fn replication_pad3d(&self, padding: &[i64]) -> Tensor
pub fn replication_pad3d_backward(
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
pub fn replication_pad3d_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
pub fn replication_pad3d_out(&self, out: &Tensor, padding: &[i64]) -> Tensor
pub fn requires_grad_(&mut self, requires_grad: bool) -> Tensor
pub fn reshape(&self, shape: &[i64]) -> Tensor
pub fn reshape_as(&self, other: &Tensor) -> Tensor
pub fn resize_(&mut self, size: &[i64]) -> Tensor
pub fn resize_as_(&mut self, the_template: &Tensor) -> Tensor
pub fn resize_as_sparse_(&mut self, the_template: &Tensor) -> Tensor
pub fn resolve_conj(&self) -> Tensor
pub fn resolve_neg(&self) -> Tensor
pub fn retains_grad(&self) -> bool
pub fn rnn_relu<T: Borrow<Tensor>>(
&self,
hx: &Tensor,
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool,
batch_first: bool
) -> (Tensor, Tensor)
pub fn rnn_relu_cell<T: Borrow<Tensor>>(
&self,
hx: &Tensor,
w_ih: &Tensor,
w_hh: &Tensor,
b_ih: Option<T>,
b_hh: Option<T>
) -> Tensor
pub fn rnn_relu_data<T: Borrow<Tensor>>(
data: &Tensor,
batch_sizes: &Tensor,
hx: &Tensor,
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool
) -> (Tensor, Tensor)
pub fn rnn_tanh<T: Borrow<Tensor>>(
&self,
hx: &Tensor,
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool,
batch_first: bool
) -> (Tensor, Tensor)
pub fn rnn_tanh_cell<T: Borrow<Tensor>>(
&self,
hx: &Tensor,
w_ih: &Tensor,
w_hh: &Tensor,
b_ih: Option<T>,
b_hh: Option<T>
) -> Tensor
pub fn rnn_tanh_data<T: Borrow<Tensor>>(
data: &Tensor,
batch_sizes: &Tensor,
hx: &Tensor,
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool
) -> (Tensor, Tensor)
pub fn roll(&self, shifts: &[i64], dims: &[i64]) -> Tensor
pub fn rot90(&self, k: i64, dims: &[i64]) -> Tensor
pub fn round(&self) -> Tensor
pub fn round_(&mut self) -> Tensor
pub fn round_decimals(&self, decimals: i64) -> Tensor
pub fn round_decimals_(&mut self, decimals: i64) -> Tensor
pub fn round_decimals_out(&self, out: &Tensor, decimals: i64) -> Tensor
pub fn round_out(&self, out: &Tensor) -> Tensor
pub fn row_stack<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor
pub fn row_stack_out<T: Borrow<Tensor>>(out: &Tensor, tensors: &[T]) -> Tensor
pub fn rrelu(&self, training: bool) -> Tensor
pub fn rrelu_(&mut self, training: bool) -> Tensor
pub fn rrelu_with_noise(&self, noise: &Tensor, training: bool) -> Tensor
pub fn rrelu_with_noise_(&mut self, noise: &Tensor, training: bool) -> Tensor
pub fn rrelu_with_noise_backward<S: Into<Scalar>>(
&self,
grad_output: &Tensor,
noise: &Tensor,
lower: S,
upper: S,
training: bool,
self_is_result: bool
) -> Tensor
pub fn rrelu_with_noise_out(
&self,
out: &Tensor,
noise: &Tensor,
training: bool
) -> Tensor
pub fn rsqrt(&self) -> Tensor
pub fn rsqrt_(&mut self) -> Tensor
pub fn rsqrt_out(&self, out: &Tensor) -> Tensor
pub fn rsub(&self, other: &Tensor) -> Tensor
pub fn rsub_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn scalar_tensor<S: Into<Scalar>>(s: S, options: (Kind, Device)) -> Tensor
pub fn scatter(&self, dim: i64, index: &Tensor, src: &Tensor) -> Tensor
pub fn scatter_(&mut self, dim: i64, index: &Tensor, src: &Tensor) -> Tensor
pub fn scatter_add(&self, dim: i64, index: &Tensor, src: &Tensor) -> Tensor
pub fn scatter_add_(&mut self, dim: i64, index: &Tensor, src: &Tensor) -> Tensor
pub fn scatter_add_out(
&self,
out: &Tensor,
dim: i64,
index: &Tensor,
src: &Tensor
) -> Tensor
pub fn scatter_reduce(
&self,
dim: i64,
index: &Tensor,
src: &Tensor,
reduce: &str
) -> Tensor
pub fn scatter_reduce_(
&mut self,
dim: i64,
index: &Tensor,
src: &Tensor,
reduce: &str
) -> Tensor
pub fn scatter_reduce_out(
&self,
out: &Tensor,
dim: i64,
index: &Tensor,
src: &Tensor,
reduce: &str
) -> Tensor
pub fn scatter_src_out(
&self,
out: &Tensor,
dim: i64,
index: &Tensor,
src: &Tensor
) -> Tensor
pub fn scatter_value<S: Into<Scalar>>(
&self,
dim: i64,
index: &Tensor,
value: S
) -> Tensor
pub fn scatter_value_<S: Into<Scalar>>(
&mut self,
dim: i64,
index: &Tensor,
value: S
) -> Tensor
pub fn scatter_value_out<S: Into<Scalar>>(
&self,
out: &Tensor,
dim: i64,
index: &Tensor,
value: S
) -> Tensor
pub fn scatter_value_reduce<S: Into<Scalar>>(
&self,
dim: i64,
index: &Tensor,
value: S,
reduce: &str
) -> Tensor
pub fn scatter_value_reduce_<S: Into<Scalar>>(
&mut self,
dim: i64,
index: &Tensor,
value: S,
reduce: &str
) -> Tensor
pub fn scatter_value_reduce_out<S: Into<Scalar>>(
&self,
out: &Tensor,
dim: i64,
index: &Tensor,
value: S,
reduce: &str
) -> Tensor
pub fn searchsorted<T: Borrow<Tensor>>(
&self,
sorted_sequence: &Tensor,
out_int32: bool,
right: bool,
side: &str,
sorter: Option<T>
) -> Tensor
pub fn searchsorted_scalar<T: Borrow<Tensor>, S: Into<Scalar>>(
sorted_sequence: &Tensor,
self_scalar: S,
out_int32: bool,
right: bool,
side: &str,
sorter: Option<T>
) -> Tensor
pub fn searchsorted_tensor_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
sorted_sequence: &Tensor,
out_int32: bool,
right: bool,
side: &str,
sorter: Option<T>
) -> Tensor
pub fn segment_reduce<T: Borrow<Tensor>, S: Into<Scalar>>(
data: &Tensor,
reduce: &str,
lengths: Option<T>,
indices: Option<T>,
axis: i64,
unsafe_: bool,
initial: S
) -> Tensor
pub fn select(&self, dim: i64, index: i64) -> Tensor
pub fn select_backward(
grad_output: &Tensor,
input_sizes: &[i64],
dim: i64,
index: i64
) -> Tensor
pub fn select_scatter(&self, src: &Tensor, dim: i64, index: i64) -> Tensor
pub fn selu(&self) -> Tensor
pub fn selu_(&mut self) -> Tensor
pub fn set_(&mut self) -> Tensor
pub fn set_data(&mut self, new_data: &Tensor)
pub fn set_requires_grad(&self, r: bool) -> Tensor
pub fn set_source_tensor_(&mut self, source: &Tensor) -> Tensor
pub fn sgn(&self) -> Tensor
pub fn sgn_(&mut self) -> Tensor
pub fn sgn_out(&self, out: &Tensor) -> Tensor
pub fn sigmoid(&self) -> Tensor
pub fn sigmoid_(&mut self) -> Tensor
pub fn sigmoid_backward(grad_output: &Tensor, output: &Tensor) -> Tensor
pub fn sigmoid_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output: &Tensor
) -> Tensor
pub fn sigmoid_out(&self, out: &Tensor) -> Tensor
pub fn sign(&self) -> Tensor
pub fn sign_(&mut self) -> Tensor
pub fn sign_out(&self, out: &Tensor) -> Tensor
pub fn signbit(&self) -> Tensor
pub fn signbit_out(&self, out: &Tensor) -> Tensor
pub fn silu(&self) -> Tensor
pub fn silu_(&mut self) -> Tensor
pub fn silu_backward(&self, grad_output: &Tensor) -> Tensor
pub fn silu_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor
) -> Tensor
pub fn silu_out(&self, out: &Tensor) -> Tensor
pub fn sin(&self) -> Tensor
pub fn sin_(&mut self) -> Tensor
pub fn sin_out(&self, out: &Tensor) -> Tensor
pub fn sinc(&self) -> Tensor
pub fn sinc_(&mut self) -> Tensor
pub fn sinc_out(&self, out: &Tensor) -> Tensor
pub fn sinh(&self) -> Tensor
pub fn sinh_(&mut self) -> Tensor
pub fn sinh_out(&self, out: &Tensor) -> Tensor
pub fn slice(
&self,
dim: i64,
start: impl Into<Option<i64>>,
end: impl Into<Option<i64>>,
step: i64
) -> Tensor
pub fn slice_backward(
grad_output: &Tensor,
input_sizes: &[i64],
dim: i64,
start: i64,
end: i64,
step: i64
) -> Tensor
pub fn slice_scatter(
&self,
src: &Tensor,
dim: i64,
start: impl Into<Option<i64>>,
end: impl Into<Option<i64>>,
step: i64
) -> Tensor
pub fn slogdet(&self) -> (Tensor, Tensor)
pub fn slow_conv3d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
kernel_size: &[i64],
bias: Option<T>,
stride: &[i64],
padding: &[i64]
) -> Tensor
pub fn slow_conv3d_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
weight: &Tensor,
kernel_size: &[i64],
bias: Option<T>,
stride: &[i64],
padding: &[i64]
) -> Tensor
pub fn slow_conv_dilated2d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
kernel_size: &[i64],
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64]
) -> Tensor
pub fn slow_conv_dilated3d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
kernel_size: &[i64],
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64]
) -> Tensor
pub fn slow_conv_transpose2d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
kernel_size: &[i64],
bias: Option<T>,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
dilation: &[i64]
) -> Tensor
pub fn slow_conv_transpose2d_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
weight: &Tensor,
kernel_size: &[i64],
bias: Option<T>,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
dilation: &[i64]
) -> Tensor
pub fn slow_conv_transpose3d<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
kernel_size: &[i64],
bias: Option<T>,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
dilation: &[i64]
) -> Tensor
pub fn slow_conv_transpose3d_out<T: Borrow<Tensor>>(
&self,
out: &Tensor,
weight: &Tensor,
kernel_size: &[i64],
bias: Option<T>,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
dilation: &[i64]
) -> Tensor
pub fn smm(&self, mat2: &Tensor) -> Tensor
pub fn smooth_l1_loss(
&self,
target: &Tensor,
reduction: Reduction,
beta: f64
) -> Tensor
pub fn smooth_l1_loss_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction,
beta: f64
) -> Tensor
pub fn smooth_l1_loss_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction,
beta: f64
) -> Tensor
pub fn smooth_l1_loss_out(
&self,
out: &Tensor,
target: &Tensor,
reduction: Reduction,
beta: f64
) -> Tensor
pub fn soft_margin_loss(&self, target: &Tensor, reduction: Reduction) -> Tensor
pub fn soft_margin_loss_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction
) -> Tensor
pub fn soft_margin_loss_backward_grad_input(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: Reduction
) -> Tensor
pub fn soft_margin_loss_out(
&self,
out: &Tensor,
target: &Tensor,
reduction: Reduction
) -> Tensor
pub fn softmax(&self, dim: i64, dtype: Kind) -> Tensor
pub fn softplus(&self) -> Tensor
pub fn softplus_backward<S: Into<Scalar>>(
&self,
grad_output: &Tensor,
beta: S,
threshold: S
) -> Tensor
pub fn softplus_backward_grad_input<S: Into<Scalar>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
beta: S,
threshold: S
) -> Tensor
pub fn softplus_out(&self, out: &Tensor) -> Tensor
pub fn softshrink(&self) -> Tensor
pub fn softshrink_backward<S: Into<Scalar>>(
&self,
grad_output: &Tensor,
lambd: S
) -> Tensor
pub fn softshrink_backward_grad_input<S: Into<Scalar>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
lambd: S
) -> Tensor
pub fn softshrink_out(&self, out: &Tensor) -> Tensor
pub fn solve(&self, a: &Tensor) -> (Tensor, Tensor)
pub fn solve_solution(
&self,
solution: &Tensor,
lu: &Tensor,
a: &Tensor
) -> (Tensor, Tensor)
pub fn sort(&self, dim: i64, descending: bool) -> (Tensor, Tensor)
pub fn sort_stable(
&self,
stable: bool,
dim: i64,
descending: bool
) -> (Tensor, Tensor)
pub fn sort_values(
&self,
values: &Tensor,
indices: &Tensor,
dim: i64,
descending: bool
) -> (Tensor, Tensor)
pub fn sort_values_stable(
&self,
values: &Tensor,
indices: &Tensor,
stable: bool,
dim: i64,
descending: bool
) -> (Tensor, Tensor)
pub fn sparse_coo_tensor(size: &[i64], options: (Kind, Device)) -> Tensor
pub fn sparse_coo_tensor_indices(
indices: &Tensor,
values: &Tensor,
options: (Kind, Device)
) -> Tensor
pub fn sparse_coo_tensor_indices_size(
indices: &Tensor,
values: &Tensor,
size: &[i64],
options: (Kind, Device)
) -> Tensor
pub fn sparse_csr_tensor(
crow_indices: &Tensor,
col_indices: &Tensor,
values: &Tensor,
options: (Kind, Device)
) -> Tensor
pub fn sparse_csr_tensor_crow_col_value_size(
crow_indices: &Tensor,
col_indices: &Tensor,
values: &Tensor,
size: &[i64],
options: (Kind, Device)
) -> Tensor
pub fn sparse_dim(&self) -> i64
pub fn sparse_mask(&self, mask: &Tensor) -> Tensor
pub fn sparse_resize_(
&mut self,
size: &[i64],
sparse_dim: i64,
dense_dim: i64
) -> Tensor
pub fn sparse_resize_and_clear_(
&mut self,
size: &[i64],
sparse_dim: i64,
dense_dim: i64
) -> Tensor
pub fn sparse_sampled_addmm(&self, mat1: &Tensor, mat2: &Tensor) -> Tensor
pub fn sparse_sampled_addmm_out(
&self,
out: &Tensor,
mat1: &Tensor,
mat2: &Tensor
) -> Tensor
pub fn special_digamma(&self) -> Tensor
pub fn special_digamma_out(&self, out: &Tensor) -> Tensor
pub fn special_entr(&self) -> Tensor
pub fn special_entr_out(&self, out: &Tensor) -> Tensor
pub fn special_erf(&self) -> Tensor
pub fn special_erf_out(&self, out: &Tensor) -> Tensor
pub fn special_erfc(&self) -> Tensor
pub fn special_erfc_out(&self, out: &Tensor) -> Tensor
pub fn special_erfcx(&self) -> Tensor
pub fn special_erfcx_out(&self, out: &Tensor) -> Tensor
pub fn special_erfinv(&self) -> Tensor
pub fn special_erfinv_out(&self, out: &Tensor) -> Tensor
pub fn special_exp2(&self) -> Tensor
pub fn special_exp2_out(&self, out: &Tensor) -> Tensor
pub fn special_expit(&self) -> Tensor
pub fn special_expit_out(&self, out: &Tensor) -> Tensor
pub fn special_expm1(&self) -> Tensor
pub fn special_expm1_out(&self, out: &Tensor) -> Tensor
pub fn special_gammainc(&self, other: &Tensor) -> Tensor
pub fn special_gammainc_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn special_gammaincc(&self, other: &Tensor) -> Tensor
pub fn special_gammaincc_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn special_gammaln(&self) -> Tensor
pub fn special_gammaln_out(&self, out: &Tensor) -> Tensor
pub fn special_i0(&self) -> Tensor
pub fn special_i0_out(&self, out: &Tensor) -> Tensor
pub fn special_i0e(&self) -> Tensor
pub fn special_i0e_out(&self, out: &Tensor) -> Tensor
pub fn special_i1(&self) -> Tensor
pub fn special_i1_out(&self, out: &Tensor) -> Tensor
pub fn special_i1e(&self) -> Tensor
pub fn special_i1e_out(&self, out: &Tensor) -> Tensor
pub fn special_log1p(&self) -> Tensor
pub fn special_log1p_out(&self, out: &Tensor) -> Tensor
pub fn special_log_softmax(&self, dim: i64, dtype: Kind) -> Tensor
pub fn special_logit(&self, eps: impl Into<Option<f64>>) -> Tensor
pub fn special_logit_out(
&self,
out: &Tensor,
eps: impl Into<Option<f64>>
) -> Tensor
pub fn special_logsumexp(&self, dim: &[i64], keepdim: bool) -> Tensor
pub fn special_logsumexp_out(
&self,
out: &Tensor,
dim: &[i64],
keepdim: bool
) -> Tensor
pub fn special_multigammaln(&self, p: i64) -> Tensor
pub fn special_multigammaln_out(&self, out: &Tensor, p: i64) -> Tensor
pub fn special_ndtr(&self) -> Tensor
pub fn special_ndtr_out(&self, out: &Tensor) -> Tensor
pub fn special_ndtri(&self) -> Tensor
pub fn special_ndtri_out(&self, out: &Tensor) -> Tensor
pub fn special_polygamma(&self, n: i64) -> Tensor
pub fn special_polygamma_out(&self, out: &Tensor, n: i64) -> Tensor
pub fn special_psi(&self) -> Tensor
pub fn special_psi_out(&self, out: &Tensor) -> Tensor
pub fn special_round(&self, decimals: i64) -> Tensor
pub fn special_round_out(&self, out: &Tensor, decimals: i64) -> Tensor
pub fn special_sinc(&self) -> Tensor
pub fn special_sinc_out(&self, out: &Tensor) -> Tensor
pub fn special_softmax(&self, dim: i64, dtype: Kind) -> Tensor
pub fn special_xlog1py(&self, other: &Tensor) -> Tensor
pub fn special_xlog1py_other_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn special_xlog1py_other_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Tensor
pub fn special_xlog1py_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn special_xlog1py_self_scalar<S: Into<Scalar>>(
self_scalar: S,
other: &Tensor
) -> Tensor
pub fn special_xlog1py_self_scalar_out<S: Into<Scalar>>(
out: &Tensor,
self_scalar: S,
other: &Tensor
) -> Tensor
pub fn special_xlogy(&self, other: &Tensor) -> Tensor
pub fn special_xlogy_other_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn special_xlogy_other_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Tensor
pub fn special_xlogy_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn special_xlogy_self_scalar<S: Into<Scalar>>(
self_scalar: S,
other: &Tensor
) -> Tensor
pub fn special_xlogy_self_scalar_out<S: Into<Scalar>>(
out: &Tensor,
self_scalar: S,
other: &Tensor
) -> Tensor
pub fn special_zeta(&self, other: &Tensor) -> Tensor
pub fn special_zeta_other_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn special_zeta_other_scalar_out<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Tensor
pub fn special_zeta_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn special_zeta_self_scalar<S: Into<Scalar>>(
self_scalar: S,
other: &Tensor
) -> Tensor
pub fn special_zeta_self_scalar_out<S: Into<Scalar>>(
out: &Tensor,
self_scalar: S,
other: &Tensor
) -> Tensor
pub fn split(&self, split_size: i64, dim: i64) -> Vec<Tensor>
pub fn split_with_sizes(&self, split_sizes: &[i64], dim: i64) -> Vec<Tensor>
pub fn sqrt(&self) -> Tensor
pub fn sqrt_(&mut self) -> Tensor
pub fn sqrt_out(&self, out: &Tensor) -> Tensor
pub fn square(&self) -> Tensor
pub fn square_(&mut self) -> Tensor
pub fn square_out(&self, out: &Tensor) -> Tensor
pub fn squeeze(&self) -> Tensor
pub fn squeeze_(&mut self) -> Tensor
pub fn squeeze_dim(&self, dim: i64) -> Tensor
pub fn squeeze_dim_(&mut self, dim: i64) -> Tensor
pub fn sspaddmm(&self, mat1: &Tensor, mat2: &Tensor) -> Tensor
pub fn sspaddmm_out(&self, out: &Tensor, mat1: &Tensor, mat2: &Tensor) -> Tensor
pub fn stack<T: Borrow<Tensor>>(tensors: &[T], dim: i64) -> Tensor
pub fn stack_out<T: Borrow<Tensor>>(
out: &Tensor,
tensors: &[T],
dim: i64
) -> Tensor
pub fn std(&self, unbiased: bool) -> Tensor
pub fn std_correction<'a>(
&self,
dim: impl Into<Option<&'a [i64]>>,
correction: impl Into<Option<i64>>,
keepdim: bool
) -> Tensor
pub fn std_correction_out<'a>(
&self,
out: &Tensor,
dim: impl Into<Option<&'a [i64]>>,
correction: impl Into<Option<i64>>,
keepdim: bool
) -> Tensor
pub fn std_dim(&self, dim: &[i64], unbiased: bool, keepdim: bool) -> Tensor
pub fn std_mean(&self, unbiased: bool) -> (Tensor, Tensor)
pub fn std_mean_correction<'a>(
&self,
dim: impl Into<Option<&'a [i64]>>,
correction: impl Into<Option<i64>>,
keepdim: bool
) -> (Tensor, Tensor)
pub fn std_mean_dim(
&self,
dim: &[i64],
unbiased: bool,
keepdim: bool
) -> (Tensor, Tensor)
pub fn std_out(
&self,
out: &Tensor,
dim: &[i64],
unbiased: bool,
keepdim: bool
) -> Tensor
pub fn stft<T: Borrow<Tensor>>(
&self,
n_fft: i64,
hop_length: impl Into<Option<i64>>,
win_length: impl Into<Option<i64>>,
window: Option<T>,
normalized: bool,
onesided: bool,
return_complex: bool
) -> Tensor
pub fn g_sub(&self, other: &Tensor) -> Tensor
pub fn g_sub_(&mut self, other: &Tensor) -> Tensor
pub fn sub_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn g_sub_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn g_sub_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn subtract(&self, other: &Tensor) -> Tensor
pub fn subtract_(&mut self, other: &Tensor) -> Tensor
pub fn subtract_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn subtract_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn subtract_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn sum(&self, dtype: Kind) -> Tensor
pub fn sum_dim_intlist(&self, dim: &[i64], keepdim: bool, dtype: Kind) -> Tensor
pub fn sum_intlist_out(
&self,
out: &Tensor,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Tensor
pub fn sum_to_size(&self, size: &[i64]) -> Tensor
pub fn svd(&self, some: bool, compute_uv: bool) -> (Tensor, Tensor, Tensor)
pub fn svd_u(
&self,
u: &Tensor,
s: &Tensor,
v: &Tensor,
some: bool,
compute_uv: bool
) -> (Tensor, Tensor, Tensor)
pub fn swapaxes(&self, axis0: i64, axis1: i64) -> Tensor
pub fn swapaxes_(&mut self, axis0: i64, axis1: i64) -> Tensor
pub fn swapdims(&self, dim0: i64, dim1: i64) -> Tensor
pub fn swapdims_(&mut self, dim0: i64, dim1: i64) -> Tensor
pub fn symeig(&self, eigenvectors: bool, upper: bool) -> (Tensor, Tensor)
pub fn symeig_e(
&self,
e: &Tensor,
v: &Tensor,
eigenvectors: bool,
upper: bool
) -> (Tensor, Tensor)
pub fn tr(&self) -> Tensor
pub fn t_(&mut self) -> Tensor
pub fn take(&self, index: &Tensor) -> Tensor
pub fn take_along_dim(
&self,
indices: &Tensor,
dim: impl Into<Option<i64>>
) -> Tensor
pub fn take_along_dim_out(
&self,
out: &Tensor,
indices: &Tensor,
dim: impl Into<Option<i64>>
) -> Tensor
pub fn take_out(&self, out: &Tensor, index: &Tensor) -> Tensor
pub fn tan(&self) -> Tensor
pub fn tan_(&mut self) -> Tensor
pub fn tan_out(&self, out: &Tensor) -> Tensor
pub fn tanh(&self) -> Tensor
pub fn tanh_(&mut self) -> Tensor
pub fn tanh_backward(grad_output: &Tensor, output: &Tensor) -> Tensor
pub fn tanh_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output: &Tensor
) -> Tensor
pub fn tanh_out(&self, out: &Tensor) -> Tensor
pub fn tensor_split(&self, sections: i64, dim: i64) -> Vec<Tensor>
pub fn tensor_split_indices(&self, indices: &[i64], dim: i64) -> Vec<Tensor>
pub fn tensor_split_tensor_indices_or_sections(
&self,
tensor_indices_or_sections: &Tensor,
dim: i64
) -> Vec<Tensor>
pub fn tensordot(
&self,
other: &Tensor,
dims_self: &[i64],
dims_other: &[i64]
) -> Tensor
pub fn tensordot_out(
&self,
out: &Tensor,
other: &Tensor,
dims_self: &[i64],
dims_other: &[i64]
) -> Tensor
pub fn threshold<S: Into<Scalar>>(&self, threshold: S, value: S) -> Tensor
pub fn threshold_<S: Into<Scalar>>(&mut self, threshold: S, value: S) -> Tensor
pub fn threshold_backward<S: Into<Scalar>>(
&self,
grad_output: &Tensor,
threshold: S
) -> Tensor
pub fn threshold_backward_grad_input<S: Into<Scalar>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
threshold: S
) -> Tensor
pub fn threshold_out<S: Into<Scalar>>(
&self,
out: &Tensor,
threshold: S,
value: S
) -> Tensor
pub fn tile(&self, dims: &[i64]) -> Tensor
pub fn to(&self, device: Device) -> Tensor
pub fn to_dense(&self, dtype: Kind) -> Tensor
pub fn to_dense_backward(&self, grad: &Tensor) -> Tensor
pub fn to_device_(
&self,
device: Device,
dtype: Kind,
non_blocking: bool,
copy: bool
) -> Tensor
pub fn to_dtype(&self, dtype: Kind, non_blocking: bool, copy: bool) -> Tensor
pub fn to_dtype_layout(
&self,
options: (Kind, Device),
non_blocking: bool,
copy: bool
) -> Tensor
pub fn g_to_mkldnn(&self, dtype: Kind) -> Tensor
pub fn to_mkldnn_backward(&self, grad: &Tensor) -> Tensor
pub fn to_other(&self, other: &Tensor, non_blocking: bool, copy: bool) -> Tensor
pub fn to_sparse(&self) -> Tensor
pub fn to_sparse_sparse_dim(&self, sparse_dim: i64) -> Tensor
pub fn topk(
&self,
k: i64,
dim: i64,
largest: bool,
sorted: bool
) -> (Tensor, Tensor)
pub fn topk_values(
&self,
values: &Tensor,
indices: &Tensor,
k: i64,
dim: i64,
largest: bool,
sorted: bool
) -> (Tensor, Tensor)
pub fn totype(&self, scalar_type: Kind) -> Tensor
pub fn trace(&self) -> Tensor
pub fn trace_backward(grad: &Tensor, sizes: &[i64]) -> Tensor
pub fn transpose(&self, dim0: i64, dim1: i64) -> Tensor
pub fn transpose_(&mut self, dim0: i64, dim1: i64) -> Tensor
pub fn trapezoid(y: &Tensor, dim: i64) -> Tensor
pub fn trapezoid_x(y: &Tensor, x: &Tensor, dim: i64) -> Tensor
pub fn trapz(y: &Tensor, x: &Tensor, dim: i64) -> Tensor
pub fn trapz_dx(y: &Tensor, dx: f64, dim: i64) -> Tensor
pub fn triangular_solve(
&self,
a: &Tensor,
upper: bool,
transpose: bool,
unitriangular: bool
) -> (Tensor, Tensor)
pub fn triangular_solve_x(
&self,
x: &Tensor,
m: &Tensor,
a: &Tensor,
upper: bool,
transpose: bool,
unitriangular: bool
) -> (Tensor, Tensor)
pub fn tril(&self, diagonal: i64) -> Tensor
pub fn tril_(&mut self, diagonal: i64) -> Tensor
pub fn tril_indices(
row: i64,
col: i64,
offset: i64,
options: (Kind, Device)
) -> Tensor
pub fn tril_out(&self, out: &Tensor, diagonal: i64) -> Tensor
pub fn triplet_margin_loss(
anchor: &Tensor,
positive: &Tensor,
negative: &Tensor,
margin: f64,
p: f64,
eps: f64,
swap: bool,
reduction: Reduction
) -> Tensor
pub fn triu(&self, diagonal: i64) -> Tensor
pub fn triu_(&mut self, diagonal: i64) -> Tensor
pub fn triu_indices(
row: i64,
col: i64,
offset: i64,
options: (Kind, Device)
) -> Tensor
pub fn triu_out(&self, out: &Tensor, diagonal: i64) -> Tensor
pub fn true_divide(&self, other: &Tensor) -> Tensor
pub fn true_divide_(&mut self, other: &Tensor) -> Tensor
pub fn true_divide_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn true_divide_scalar<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn true_divide_scalar_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn trunc(&self) -> Tensor
pub fn trunc_(&mut self) -> Tensor
pub fn trunc_out(&self, out: &Tensor) -> Tensor
pub fn type_as(&self, other: &Tensor) -> Tensor
pub fn unbind(&self, dim: i64) -> Vec<Tensor>
pub fn unflatten(&self, dim: i64, sizes: &[i64]) -> Tensor
pub fn unflatten_dense_tensors<T: Borrow<Tensor>>(
flat: &Tensor,
tensors: &[T]
) -> Vec<Tensor>
pub fn unfold(&self, dimension: i64, size: i64, step: i64) -> Tensor
pub fn unfold_backward(
grad_in: &Tensor,
input_sizes: &[i64],
dim: i64,
size: i64,
step: i64
) -> Tensor
pub fn uniform_(&mut self, from: f64, to: f64) -> Tensor
pub fn unique_consecutive(
&self,
return_inverse: bool,
return_counts: bool,
dim: impl Into<Option<i64>>
) -> (Tensor, Tensor, Tensor)
pub fn unique_dim(
&self,
dim: i64,
sorted: bool,
return_inverse: bool,
return_counts: bool
) -> (Tensor, Tensor, Tensor)
pub fn unique_dim_consecutive(
&self,
dim: i64,
return_inverse: bool,
return_counts: bool
) -> (Tensor, Tensor, Tensor)
pub fn unsafe_chunk(&self, chunks: i64, dim: i64) -> Vec<Tensor>
pub fn unsafe_split(&self, split_size: i64, dim: i64) -> Vec<Tensor>
pub fn unsafe_split_with_sizes(
&self,
split_sizes: &[i64],
dim: i64
) -> Vec<Tensor>
pub fn unsqueeze(&self, dim: i64) -> Tensor
pub fn unsqueeze_(&mut self, dim: i64) -> Tensor
pub fn upsample_bicubic2d(
&self,
output_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_bicubic2d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_bicubic2d_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_bicubic2d_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
align_corners: bool,
scale_factors: &[f64]
) -> Tensor
pub fn upsample_bicubic2d_out(
&self,
out: &Tensor,
output_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_bicubic2d_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
align_corners: bool,
scale_factors: &[f64]
) -> Tensor
pub fn upsample_bilinear2d(
&self,
output_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_bilinear2d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_bilinear2d_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_bilinear2d_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
align_corners: bool,
scale_factors: &[f64]
) -> Tensor
pub fn upsample_bilinear2d_out(
&self,
out: &Tensor,
output_size: &[i64],
align_corners: bool,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_bilinear2d_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
align_corners: bool,
scale_factors: &[f64]
) -> Tensor
pub fn upsample_linear1d(
&self,
output_size: &[i64],
align_corners: bool,
scales: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_linear1d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_linear1d_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_linear1d_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
align_corners: bool,
scale_factors: &[f64]
) -> Tensor
pub fn upsample_linear1d_out(
&self,
out: &Tensor,
output_size: &[i64],
align_corners: bool,
scales: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_linear1d_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
align_corners: bool,
scale_factors: &[f64]
) -> Tensor
pub fn upsample_nearest1d(
&self,
output_size: &[i64],
scales: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_nearest1d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_nearest1d_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_nearest1d_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
scale_factors: &[f64]
) -> Tensor
pub fn upsample_nearest1d_out(
&self,
out: &Tensor,
output_size: &[i64],
scales: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_nearest1d_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
scale_factors: &[f64]
) -> Tensor
pub fn upsample_nearest2d(
&self,
output_size: &[i64],
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_nearest2d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_nearest2d_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_nearest2d_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
scale_factors: &[f64]
) -> Tensor
pub fn upsample_nearest2d_out(
&self,
out: &Tensor,
output_size: &[i64],
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_nearest2d_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
scale_factors: &[f64]
) -> Tensor
pub fn upsample_nearest3d(
&self,
output_size: &[i64],
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_nearest3d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_nearest3d_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_nearest3d_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
scale_factors: &[f64]
) -> Tensor
pub fn upsample_nearest3d_out(
&self,
out: &Tensor,
output_size: &[i64],
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_nearest3d_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
scale_factors: &[f64]
) -> Tensor
pub fn upsample_trilinear3d(
&self,
output_size: &[i64],
align_corners: bool,
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_trilinear3d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_trilinear3d_backward_grad_input(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool,
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_trilinear3d_backward_vec<'a>(
grad_output: &Tensor,
output_size: impl Into<Option<&'a [i64]>>,
input_size: &[i64],
align_corners: bool,
scale_factors: &[f64]
) -> Tensor
pub fn upsample_trilinear3d_out(
&self,
out: &Tensor,
output_size: &[i64],
align_corners: bool,
scales_d: impl Into<Option<f64>>,
scales_h: impl Into<Option<f64>>,
scales_w: impl Into<Option<f64>>
) -> Tensor
pub fn upsample_trilinear3d_vec<'a>(
&self,
output_size: impl Into<Option<&'a [i64]>>,
align_corners: bool,
scale_factors: &[f64]
) -> Tensor
pub fn value_selecting_reduction_backward(
grad: &Tensor,
dim: i64,
indices: &Tensor,
sizes: &[i64],
keepdim: bool
) -> Tensor
pub fn values(&self) -> Tensor
pub fn vander(x: &Tensor, n: impl Into<Option<i64>>, increasing: bool) -> Tensor
pub fn var(&self, unbiased: bool) -> Tensor
pub fn var_correction<'a>(
&self,
dim: impl Into<Option<&'a [i64]>>,
correction: impl Into<Option<i64>>,
keepdim: bool
) -> Tensor
pub fn var_correction_out<'a>(
&self,
out: &Tensor,
dim: impl Into<Option<&'a [i64]>>,
correction: impl Into<Option<i64>>,
keepdim: bool
) -> Tensor
pub fn var_dim(&self, dim: &[i64], unbiased: bool, keepdim: bool) -> Tensor
pub fn var_mean(&self, unbiased: bool) -> (Tensor, Tensor)
pub fn var_mean_correction<'a>(
&self,
dim: impl Into<Option<&'a [i64]>>,
correction: impl Into<Option<i64>>,
keepdim: bool
) -> (Tensor, Tensor)
pub fn var_mean_dim(
&self,
dim: &[i64],
unbiased: bool,
keepdim: bool
) -> (Tensor, Tensor)
pub fn var_out(
&self,
out: &Tensor,
dim: &[i64],
unbiased: bool,
keepdim: bool
) -> Tensor
pub fn vdot(&self, other: &Tensor) -> Tensor
pub fn vdot_out(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn view_(&self, size: &[i64]) -> Tensor
pub fn view_as(&self, other: &Tensor) -> Tensor
pub fn view_as_complex(&self) -> Tensor
pub fn view_as_real(&self) -> Tensor
pub fn view_dtype(&self, dtype: Kind) -> Tensor
pub fn vsplit(&self, sections: i64) -> Vec<Tensor>
pub fn vsplit_array(&self, indices: &[i64]) -> Vec<Tensor>
pub fn vstack<T: Borrow<Tensor>>(tensors: &[T]) -> Tensor
pub fn vstack_out<T: Borrow<Tensor>>(out: &Tensor, tensors: &[T]) -> Tensor
pub fn where_(condition: &Tensor) -> Vec<Tensor>
pub fn where_scalar<S: Into<Scalar>>(
condition: &Tensor,
self_scalar: S,
other: S
) -> Tensor
pub fn where_scalarother<S: Into<Scalar>>(
&self,
condition: &Tensor,
other: S
) -> Tensor
pub fn where_scalarself<S: Into<Scalar>>(
condition: &Tensor,
self_scalar: S,
other: &Tensor
) -> Tensor
pub fn where_self(&self, condition: &Tensor, other: &Tensor) -> Tensor
pub fn xlogy(&self, other: &Tensor) -> Tensor
pub fn xlogy_(&mut self, other: &Tensor) -> Tensor
pub fn xlogy_outscalar_other<S: Into<Scalar>>(
&self,
out: &Tensor,
other: S
) -> Tensor
pub fn xlogy_outscalar_self<S: Into<Scalar>>(
out: &Tensor,
self_scalar: S,
other: &Tensor
) -> Tensor
pub fn xlogy_outtensor(&self, out: &Tensor, other: &Tensor) -> Tensor
pub fn xlogy_scalar_other<S: Into<Scalar>>(&self, other: S) -> Tensor
pub fn xlogy_scalar_other_<S: Into<Scalar>>(&mut self, other: S) -> Tensor
pub fn xlogy_scalar_self<S: Into<Scalar>>(
self_scalar: S,
other: &Tensor
) -> Tensor
pub fn zero_(&mut self) -> Tensor
pub fn zeros(size: &[i64], options: (Kind, Device)) -> Tensor
pub fn zeros_like(&self) -> Tensor
pub fn zeros_out(out: &Tensor, size: &[i64]) -> Tensor
sourceimpl Tensor
impl Tensor
sourcepub fn read_npy<T: AsRef<Path>>(path: T) -> Result<Tensor, TchError>
pub fn read_npy<T: AsRef<Path>>(path: T) -> Result<Tensor, TchError>
Reads a npy file and return the stored tensor.
sourcepub fn read_npz<T: AsRef<Path>>(
path: T
) -> Result<Vec<(String, Tensor)>, TchError>
pub fn read_npz<T: AsRef<Path>>(
path: T
) -> Result<Vec<(String, Tensor)>, TchError>
Reads a npz file and returns some named tensors.
sourcepub fn write_npy<T: AsRef<Path>>(&self, path: T) -> Result<(), TchError>
pub fn write_npy<T: AsRef<Path>>(&self, path: T) -> Result<(), TchError>
Writes a tensor in the npy format so that it can be read using python.
pub fn write_npz<S: AsRef<str>, T: AsRef<Tensor>, P: AsRef<Path>>(
ts: &[(S, T)],
path: P
) -> Result<(), TchError>
sourceimpl Tensor
impl Tensor
pub fn f_view<T: Shape>(&self, s: T) -> Result<Tensor, TchError>
pub fn view<T: Shape>(&self, s: T) -> Tensor
pub fn f_zero_pad1d(&self, left: i64, right: i64) -> Result<Tensor, TchError>
pub fn zero_pad1d(&self, left: i64, right: i64) -> Tensor
pub fn f_zero_pad2d(
&self,
left: i64,
right: i64,
top: i64,
bottom: i64
) -> Result<Tensor, TchError>
pub fn zero_pad2d(&self, left: i64, right: i64, top: i64, bottom: i64) -> Tensor
sourceimpl Tensor
impl Tensor
sourcepub fn cross_entropy_for_logits(&self, targets: &Tensor) -> Tensor
pub fn cross_entropy_for_logits(&self, targets: &Tensor) -> Tensor
Computes the cross-entropy loss based on some logits and targets.
sourcepub fn accuracy_for_logits(&self, targets: &Tensor) -> Tensor
pub fn accuracy_for_logits(&self, targets: &Tensor) -> Tensor
Returns the average accuracy for some given logits assuming that targets represent ground-truth.
pub fn random_batch(&self, batch_size: i64) -> Tensor
pub fn random_batch2(
t1: &Tensor,
t2: &Tensor,
batch_size: i64
) -> (Tensor, Tensor)
pub fn f_to_device(&self, device: Device) -> Result<Tensor, TchError>
pub fn avg_pool2d_default(&self, ksize: i64) -> Tensor
pub fn max_pool2d_default(&self, ksize: i64) -> Tensor
sourcepub fn flat_view(&self) -> Tensor
pub fn flat_view(&self) -> Tensor
Flattens a tensor.
This returns a flattened version of the given tensor. The first dimension is preserved as it is assumed to be the mini-batch dimension.
sourcepub fn onehot(&self, labels: i64) -> Tensor
pub fn onehot(&self, labels: i64) -> Tensor
Converts a tensor to a one-hot encoded version.
If the input has a size [N1, N2, …, Nk], the returned tensor has a size [N1, …, Nk, labels]. The returned tensor uses float values. Elements of the input vector are expected to be between 0 and labels-1.
sourcepub fn copy(&self) -> Tensor
pub fn copy(&self) -> Tensor
Copies a tensor to a newly allocated tensor using the same shape and device.
pub fn of_slice2<T, U>(v: &[U]) -> Tensor where
T: Element,
U: AsRef<[T]>,
pub fn to_mkldnn(&self) -> Tensor
Trait Implementations
sourceimpl AddAssign<&'_ Tensor> for Tensor
impl AddAssign<&'_ Tensor> for Tensor
sourcefn add_assign(&mut self, rhs: &Tensor)
fn add_assign(&mut self, rhs: &Tensor)
Performs the +=
operation. Read more
sourceimpl AddAssign<Tensor> for Tensor
impl AddAssign<Tensor> for Tensor
sourcefn add_assign(&mut self, rhs: Tensor)
fn add_assign(&mut self, rhs: Tensor)
Performs the +=
operation. Read more
sourceimpl AddAssign<f32> for Tensor
impl AddAssign<f32> for Tensor
sourcefn add_assign(&mut self, rhs: f32)
fn add_assign(&mut self, rhs: f32)
Performs the +=
operation. Read more
sourceimpl AddAssign<f64> for Tensor
impl AddAssign<f64> for Tensor
sourcefn add_assign(&mut self, rhs: f64)
fn add_assign(&mut self, rhs: f64)
Performs the +=
operation. Read more
sourceimpl AddAssign<i32> for Tensor
impl AddAssign<i32> for Tensor
sourcefn add_assign(&mut self, rhs: i32)
fn add_assign(&mut self, rhs: i32)
Performs the +=
operation. Read more
sourceimpl AddAssign<i64> for Tensor
impl AddAssign<i64> for Tensor
sourcefn add_assign(&mut self, rhs: i64)
fn add_assign(&mut self, rhs: i64)
Performs the +=
operation. Read more
sourceimpl DivAssign<&'_ Tensor> for Tensor
impl DivAssign<&'_ Tensor> for Tensor
sourcefn div_assign(&mut self, rhs: &Tensor)
fn div_assign(&mut self, rhs: &Tensor)
Performs the /=
operation. Read more
sourceimpl DivAssign<Tensor> for Tensor
impl DivAssign<Tensor> for Tensor
sourcefn div_assign(&mut self, rhs: Tensor)
fn div_assign(&mut self, rhs: Tensor)
Performs the /=
operation. Read more
sourceimpl DivAssign<f32> for Tensor
impl DivAssign<f32> for Tensor
sourcefn div_assign(&mut self, rhs: f32)
fn div_assign(&mut self, rhs: f32)
Performs the /=
operation. Read more
sourceimpl DivAssign<f64> for Tensor
impl DivAssign<f64> for Tensor
sourcefn div_assign(&mut self, rhs: f64)
fn div_assign(&mut self, rhs: f64)
Performs the /=
operation. Read more
sourceimpl DivAssign<i32> for Tensor
impl DivAssign<i32> for Tensor
sourcefn div_assign(&mut self, rhs: i32)
fn div_assign(&mut self, rhs: i32)
Performs the /=
operation. Read more
sourceimpl DivAssign<i64> for Tensor
impl DivAssign<i64> for Tensor
sourcefn div_assign(&mut self, rhs: i64)
fn div_assign(&mut self, rhs: i64)
Performs the /=
operation. Read more
sourceimpl From<&'_ Tensor> for TensorIndexer
impl From<&'_ Tensor> for TensorIndexer
sourceimpl<A, B, C, D, E, F, G> IndexOp<(A, B, C, D, E, F, G)> for Tensor where
A: Into<TensorIndexer>,
B: Into<TensorIndexer>,
C: Into<TensorIndexer>,
D: Into<TensorIndexer>,
E: Into<TensorIndexer>,
F: Into<TensorIndexer>,
G: Into<TensorIndexer>,
impl<A, B, C, D, E, F, G> IndexOp<(A, B, C, D, E, F, G)> for Tensor where
A: Into<TensorIndexer>,
B: Into<TensorIndexer>,
C: Into<TensorIndexer>,
D: Into<TensorIndexer>,
E: Into<TensorIndexer>,
F: Into<TensorIndexer>,
G: Into<TensorIndexer>,
sourceimpl<A, B, C, D, E, F> IndexOp<(A, B, C, D, E, F)> for Tensor where
A: Into<TensorIndexer>,
B: Into<TensorIndexer>,
C: Into<TensorIndexer>,
D: Into<TensorIndexer>,
E: Into<TensorIndexer>,
F: Into<TensorIndexer>,
impl<A, B, C, D, E, F> IndexOp<(A, B, C, D, E, F)> for Tensor where
A: Into<TensorIndexer>,
B: Into<TensorIndexer>,
C: Into<TensorIndexer>,
D: Into<TensorIndexer>,
E: Into<TensorIndexer>,
F: Into<TensorIndexer>,
sourceimpl<A, B, C, D, E> IndexOp<(A, B, C, D, E)> for Tensor where
A: Into<TensorIndexer>,
B: Into<TensorIndexer>,
C: Into<TensorIndexer>,
D: Into<TensorIndexer>,
E: Into<TensorIndexer>,
impl<A, B, C, D, E> IndexOp<(A, B, C, D, E)> for Tensor where
A: Into<TensorIndexer>,
B: Into<TensorIndexer>,
C: Into<TensorIndexer>,
D: Into<TensorIndexer>,
E: Into<TensorIndexer>,
sourceimpl<A, B, C, D> IndexOp<(A, B, C, D)> for Tensor where
A: Into<TensorIndexer>,
B: Into<TensorIndexer>,
C: Into<TensorIndexer>,
D: Into<TensorIndexer>,
impl<A, B, C, D> IndexOp<(A, B, C, D)> for Tensor where
A: Into<TensorIndexer>,
B: Into<TensorIndexer>,
C: Into<TensorIndexer>,
D: Into<TensorIndexer>,
sourceimpl<A, B, C> IndexOp<(A, B, C)> for Tensor where
A: Into<TensorIndexer>,
B: Into<TensorIndexer>,
C: Into<TensorIndexer>,
impl<A, B, C> IndexOp<(A, B, C)> for Tensor where
A: Into<TensorIndexer>,
B: Into<TensorIndexer>,
C: Into<TensorIndexer>,
sourceimpl<A, B> IndexOp<(A, B)> for Tensor where
A: Into<TensorIndexer>,
B: Into<TensorIndexer>,
impl<A, B> IndexOp<(A, B)> for Tensor where
A: Into<TensorIndexer>,
B: Into<TensorIndexer>,
sourceimpl<A> IndexOp<A> for Tensor where
A: Into<TensorIndexer>,
impl<A> IndexOp<A> for Tensor where
A: Into<TensorIndexer>,
sourceimpl MulAssign<&'_ Tensor> for Tensor
impl MulAssign<&'_ Tensor> for Tensor
sourcefn mul_assign(&mut self, rhs: &Tensor)
fn mul_assign(&mut self, rhs: &Tensor)
Performs the *=
operation. Read more
sourceimpl MulAssign<Tensor> for Tensor
impl MulAssign<Tensor> for Tensor
sourcefn mul_assign(&mut self, rhs: Tensor)
fn mul_assign(&mut self, rhs: Tensor)
Performs the *=
operation. Read more
sourceimpl MulAssign<f32> for Tensor
impl MulAssign<f32> for Tensor
sourcefn mul_assign(&mut self, rhs: f32)
fn mul_assign(&mut self, rhs: f32)
Performs the *=
operation. Read more
sourceimpl MulAssign<f64> for Tensor
impl MulAssign<f64> for Tensor
sourcefn mul_assign(&mut self, rhs: f64)
fn mul_assign(&mut self, rhs: f64)
Performs the *=
operation. Read more
sourceimpl MulAssign<i32> for Tensor
impl MulAssign<i32> for Tensor
sourcefn mul_assign(&mut self, rhs: i32)
fn mul_assign(&mut self, rhs: i32)
Performs the *=
operation. Read more
sourceimpl MulAssign<i64> for Tensor
impl MulAssign<i64> for Tensor
sourcefn mul_assign(&mut self, rhs: i64)
fn mul_assign(&mut self, rhs: i64)
Performs the *=
operation. Read more
sourceimpl SubAssign<&'_ Tensor> for Tensor
impl SubAssign<&'_ Tensor> for Tensor
sourcefn sub_assign(&mut self, rhs: &Tensor)
fn sub_assign(&mut self, rhs: &Tensor)
Performs the -=
operation. Read more
sourceimpl SubAssign<Tensor> for Tensor
impl SubAssign<Tensor> for Tensor
sourcefn sub_assign(&mut self, rhs: Tensor)
fn sub_assign(&mut self, rhs: Tensor)
Performs the -=
operation. Read more
sourceimpl SubAssign<f32> for Tensor
impl SubAssign<f32> for Tensor
sourcefn sub_assign(&mut self, rhs: f32)
fn sub_assign(&mut self, rhs: f32)
Performs the -=
operation. Read more
sourceimpl SubAssign<f64> for Tensor
impl SubAssign<f64> for Tensor
sourcefn sub_assign(&mut self, rhs: f64)
fn sub_assign(&mut self, rhs: f64)
Performs the -=
operation. Read more
sourceimpl SubAssign<i32> for Tensor
impl SubAssign<i32> for Tensor
sourcefn sub_assign(&mut self, rhs: i32)
fn sub_assign(&mut self, rhs: i32)
Performs the -=
operation. Read more
sourceimpl SubAssign<i64> for Tensor
impl SubAssign<i64> for Tensor
sourcefn sub_assign(&mut self, rhs: i64)
fn sub_assign(&mut self, rhs: i64)
Performs the -=
operation. Read more
sourceimpl<T, D> TryFrom<&'_ ArrayBase<T, D>> for Tensor where
T: Data,
T::Elem: Element,
D: Dimension,
impl<T, D> TryFrom<&'_ ArrayBase<T, D>> for Tensor where
T: Data,
T::Elem: Element,
D: Dimension,
impl Send for Tensor
Auto Trait Implementations
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more