[−][src]Struct tch::Tensor
A tensor object.
Methods
impl Tensor
[src]
pub fn new() -> Tensor
[src]
Creates a new tensor.
pub fn size(&self) -> Vec<i64>
[src]
Returns the shape of the input tensor.
pub fn size1(&self) -> Fallible<i64>
[src]
Returns the tensor size for single dimension tensors.
pub fn size2(&self) -> Fallible<(i64, i64)>
[src]
Returns the tensor sizes for two dimension tensors.
pub fn size3(&self) -> Fallible<(i64, i64, i64)>
[src]
Returns the tensor sizes for three dimension tensors.
pub fn size4(&self) -> Fallible<(i64, i64, i64, i64)>
[src]
Returns the tensor sizes for four dimension tensors.
pub fn kind(&self) -> Kind
[src]
Returns the kind of elements stored in the input tensor.
pub fn device(&self) -> Device
[src]
Returns the device on which the input tensor is located.
pub fn print(&self)
[src]
Prints the input tensor.
Caution: this uses the C++ printer which prints the whole tensor even if it is very large.
pub fn f_double_value(&self, idx: &[i64]) -> Fallible<f64>
[src]
Returns a double value on tensors holding a single element. An error is returned otherwise.
pub fn f_int64_value(&self, idx: &[i64]) -> Fallible<i64>
[src]
Returns an int value on tensors holding a single element. An error is returned otherwise.
pub fn double_value(&self, idx: &[i64]) -> f64
[src]
Returns a double value on tensors holding a single element. Panics otherwise.
pub fn int64_value(&self, idx: &[i64]) -> i64
[src]
Returns an int value on tensors holding a single element. Panics otherwise.
pub fn requires_grad(&self) -> bool
[src]
Returns true if gradient are currently tracked for this tensor.
pub fn defined(&self) -> bool
[src]
Returns true is the tensor is defined.
pub fn zero_grad(&mut self)
[src]
Zeroes the gradient tensor attached to this tensor if defined.
pub fn f_backward(&self) -> Fallible<()>
[src]
Runs the backward pass, populating the gradient tensors for tensors which gradients are tracked.
Gradients tracking can be turned on via set_requires_grad
.
pub fn backward(&self)
[src]
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
) -> Fallible<Vec<Tensor>> where
T1: Borrow<Tensor>,
T2: Borrow<Tensor>,
[src]
tensors: &[T1],
inputs: &[T2],
keep_graph: bool,
create_graph: bool
) -> Fallible<Vec<Tensor>> 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>,
[src]
tensors: &[T1],
inputs: &[T2],
keep_graph: bool,
create_graph: bool
) -> Vec<Tensor> where
T1: Borrow<Tensor>,
T2: Borrow<Tensor>,
pub fn f_copy_data<T>(&self, dst: &mut [T], numel: i64) -> Fallible<()>
[src]
Copies numel
elements from src
to this tensor.
pub fn copy_data<T>(&self, dst: &mut [T], numel: i64)
[src]
Copies numel
elements from src
to this tensor.
pub fn numel(&self) -> i64
[src]
Returns the total number of elements stored in a tensor.
pub fn f_of_slice<T: T>(data: &[T]) -> Fallible<Tensor>
[src]
Converts a slice to a tensor.
pub fn of_slice<T: T>(data: &[T]) -> Tensor
[src]
Converts a slice to a tensor.
pub fn f_of_data_size(data: &[u8], size: &[i64], kind: Kind) -> Fallible<Tensor>
[src]
Converts some byte data to a tensor with some specified kind and shape.
pub fn of_data_size(data: &[u8], size: &[i64], kind: Kind) -> Tensor
[src]
Converts some byte data to a tensor with some specified kind and shape.
pub fn shallow_clone(&self) -> Tensor
[src]
Returns a new tensor that share storage with the input tensor.
pub fn f_get(&self, index: i64) -> Fallible<Tensor>
[src]
Gets the sub-tensor at the given index.
pub fn get(&self, index: i64) -> Tensor
[src]
Gets the sub-tensor at the given index.
pub fn f_copy_(&self, src: &Tensor) -> Fallible<()>
[src]
Copies values from the argument tensor to the input tensor.
pub fn copy_(&self, src: &Tensor)
[src]
Copies values from the argument tensor to the input tensor.
pub fn load<T: AsRef<Path>>(path: T) -> Fallible<Tensor>
[src]
Loads a tensor from a file.
The file format is the same as the one used by the PyTorch C++ API.
pub fn save<T: AsRef<Path>>(&self, path: T) -> Fallible<()>
[src]
Saves a tensor to a file.
The file format is the same as the one used by the PyTorch C++ API.
pub fn save_multi<S: AsRef<str>, T: AsRef<Tensor>, P: AsRef<Path>>(
named_tensors: &[(S, T)],
path: P
) -> Fallible<()>
[src]
named_tensors: &[(S, T)],
path: P
) -> Fallible<()>
Saves some named tensors to a file
The file format is the same as the one used by the PyTorch C++ API.
pub fn load_multi<T: AsRef<Path>>(path: T) -> Fallible<Vec<(String, Tensor)>>
[src]
Loads some named tensors from a file
The file format is the same as the one used by the PyTorch C++ API.
pub fn to_string(&self, lw: i64) -> Fallible<String>
[src]
Returns a string representation for the tensor.
The representation will contain all the tensor element hence may be huge for large tensors.
impl Tensor
[src]
pub fn f_abs(&self) -> Fallible<Tensor>
[src]
pub fn f_abs_(&self) -> Fallible<Tensor>
[src]
pub fn f_abs_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_acos(&self) -> Fallible<Tensor>
[src]
pub fn f_acos_(&self) -> Fallible<Tensor>
[src]
pub fn f_acos_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_adaptive_avg_pool1d(&self, output_size: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_adaptive_avg_pool2d(&self, output_size: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_adaptive_avg_pool2d_backward(
&self,
grad_output: &Tensor
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor
) -> Fallible<Tensor>
pub fn f_adaptive_avg_pool2d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor
) -> Fallible<Tensor>
pub fn f_adaptive_avg_pool2d_out(
&self,
output: &Tensor,
output_size: &[i64]
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
output_size: &[i64]
) -> Fallible<Tensor>
pub fn f_adaptive_avg_pool3d(&self, output_size: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_adaptive_avg_pool3d_backward(
&self,
grad_output: &Tensor
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor
) -> Fallible<Tensor>
pub fn f_adaptive_avg_pool3d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor
) -> Fallible<Tensor>
pub fn f_adaptive_avg_pool3d_out(
&self,
output: &Tensor,
output_size: &[i64]
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
output_size: &[i64]
) -> Fallible<Tensor>
pub fn f_adaptive_max_pool1d(
&self,
output_size: &[i64]
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
output_size: &[i64]
) -> Fallible<(Tensor, Tensor)>
pub fn f_adaptive_max_pool2d(
&self,
output_size: &[i64]
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
output_size: &[i64]
) -> Fallible<(Tensor, Tensor)>
pub fn f_adaptive_max_pool2d_backward(
&self,
grad_output: &Tensor,
indices: &Tensor
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
indices: &Tensor
) -> Fallible<Tensor>
pub fn f_adaptive_max_pool2d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor
) -> Fallible<Tensor>
pub fn f_adaptive_max_pool2d_out(
&self,
output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Fallible<(Tensor, Tensor)>
pub fn f_adaptive_max_pool3d(
&self,
output_size: &[i64]
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
output_size: &[i64]
) -> Fallible<(Tensor, Tensor)>
pub fn f_adaptive_max_pool3d_backward(
&self,
grad_output: &Tensor,
indices: &Tensor
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
indices: &Tensor
) -> Fallible<Tensor>
pub fn f_adaptive_max_pool3d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor
) -> Fallible<Tensor>
pub fn f_adaptive_max_pool3d_out(
&self,
output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Fallible<(Tensor, Tensor)>
pub fn f_add(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_add1<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_add_(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_add_1<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_add_out(&self, result: &Tensor, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_addbmm(&self, batch1: &Tensor, batch2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_addbmm_(&self, batch1: &Tensor, batch2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_addbmm_out(
&self,
result: &Tensor,
batch1: &Tensor,
batch2: &Tensor
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
batch1: &Tensor,
batch2: &Tensor
) -> Fallible<Tensor>
pub fn f_addcdiv(&self, tensor1: &Tensor, tensor2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_addcdiv_(&self, tensor1: &Tensor, tensor2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_addcdiv_out(
&self,
result: &Tensor,
tensor1: &Tensor,
tensor2: &Tensor
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
tensor1: &Tensor,
tensor2: &Tensor
) -> Fallible<Tensor>
pub fn f_addcmul(&self, tensor1: &Tensor, tensor2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_addcmul_(&self, tensor1: &Tensor, tensor2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_addcmul_out(
&self,
result: &Tensor,
tensor1: &Tensor,
tensor2: &Tensor
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
tensor1: &Tensor,
tensor2: &Tensor
) -> Fallible<Tensor>
pub fn f_addmm(&self, mat1: &Tensor, mat2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_addmm_(&self, mat1: &Tensor, mat2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_addmm_out(
&self,
result: &Tensor,
mat1: &Tensor,
mat2: &Tensor
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
mat1: &Tensor,
mat2: &Tensor
) -> Fallible<Tensor>
pub fn f_addmv(&self, mat: &Tensor, vec: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_addmv_(&self, mat: &Tensor, vec: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_addmv_out(
&self,
result: &Tensor,
mat: &Tensor,
vec: &Tensor
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
mat: &Tensor,
vec: &Tensor
) -> Fallible<Tensor>
pub fn f_addr(&self, vec1: &Tensor, vec2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_addr_(&self, vec1: &Tensor, vec2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_addr_out(
&self,
result: &Tensor,
vec1: &Tensor,
vec2: &Tensor
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
vec1: &Tensor,
vec2: &Tensor
) -> Fallible<Tensor>
pub fn f_alias(&self) -> Fallible<Tensor>
[src]
pub fn f_all(&self) -> Fallible<Tensor>
[src]
pub fn f_all1(&self, dim: i64, keepdim: bool) -> Fallible<Tensor>
[src]
pub fn f_all_out(
&self,
result: &Tensor,
dim: i64,
keepdim: bool
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
dim: i64,
keepdim: bool
) -> Fallible<Tensor>
pub fn f_alpha_dropout(&self, p: f64, train: bool) -> Fallible<Tensor>
[src]
pub fn f_alpha_dropout_(&self, p: f64, train: bool) -> Fallible<Tensor>
[src]
pub fn f_any(&self) -> Fallible<Tensor>
[src]
pub fn f_any1(&self, dim: i64, keepdim: bool) -> Fallible<Tensor>
[src]
pub fn f_any_out(
&self,
result: &Tensor,
dim: i64,
keepdim: bool
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
dim: i64,
keepdim: bool
) -> Fallible<Tensor>
pub fn f_arange<S: Into<Scalar>>(
end_: S,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
end_: S,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_arange1<S: Into<Scalar>>(
start: S,
end_: S,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
start: S,
end_: S,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_arange2<S: Into<Scalar>>(
start: S,
end_: S,
step: S,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
start: S,
end_: S,
step: S,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_arange_out<S: Into<Scalar>>(
result: &Tensor,
end_: S
) -> Fallible<Tensor>
[src]
result: &Tensor,
end_: S
) -> Fallible<Tensor>
pub fn f_arange_out1<S: Into<Scalar>>(
result: &Tensor,
start: S,
end_: S
) -> Fallible<Tensor>
[src]
result: &Tensor,
start: S,
end_: S
) -> Fallible<Tensor>
pub fn f_arange_out2<S: Into<Scalar>>(
result: &Tensor,
start: S,
end_: S,
step: S
) -> Fallible<Tensor>
[src]
result: &Tensor,
start: S,
end_: S,
step: S
) -> Fallible<Tensor>
pub fn f_argmax(&self) -> Fallible<Tensor>
[src]
pub fn f_argmax1(&self, dim: i64, keepdim: bool) -> Fallible<Tensor>
[src]
pub fn f_argmin(&self) -> Fallible<Tensor>
[src]
pub fn f_argmin1(&self, dim: i64, keepdim: bool) -> Fallible<Tensor>
[src]
pub fn f_as_strided(&self, size: &[i64], stride: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_as_strided1(
&self,
size: &[i64],
stride: &[i64],
storage_offset: i64
) -> Fallible<Tensor>
[src]
&self,
size: &[i64],
stride: &[i64],
storage_offset: i64
) -> Fallible<Tensor>
pub fn f_as_strided_(&self, size: &[i64], stride: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_as_strided_1(
&self,
size: &[i64],
stride: &[i64],
storage_offset: i64
) -> Fallible<Tensor>
[src]
&self,
size: &[i64],
stride: &[i64],
storage_offset: i64
) -> Fallible<Tensor>
pub fn f_asin(&self) -> Fallible<Tensor>
[src]
pub fn f_asin_(&self) -> Fallible<Tensor>
[src]
pub fn f_asin_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_atan(&self) -> Fallible<Tensor>
[src]
pub fn f_atan2(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_atan2_(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_atan2_out(&self, result: &Tensor, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_atan_(&self) -> Fallible<Tensor>
[src]
pub fn f_atan_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_avg_pool1d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Fallible<Tensor>
[src]
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Fallible<Tensor>
pub fn f_avg_pool2d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Fallible<Tensor>
[src]
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Fallible<Tensor>
pub fn f_avg_pool2d_backward(
&self,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Fallible<Tensor>
pub fn f_avg_pool2d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Fallible<Tensor>
pub fn f_avg_pool2d_out(
&self,
output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Fallible<Tensor>
pub fn f_avg_pool3d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Fallible<Tensor>
[src]
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Fallible<Tensor>
pub fn f_avg_pool3d_backward(
&self,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Fallible<Tensor>
pub fn f_avg_pool3d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Fallible<Tensor>
pub fn f_avg_pool3d_out(
&self,
output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Fallible<Tensor>
pub fn f_baddbmm(&self, batch1: &Tensor, batch2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_baddbmm_(&self, batch1: &Tensor, batch2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_baddbmm_out(
&self,
result: &Tensor,
batch1: &Tensor,
batch2: &Tensor
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
batch1: &Tensor,
batch2: &Tensor
) -> Fallible<Tensor>
pub fn f_bartlett_window(
window_length: i64,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
window_length: i64,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_bartlett_window1(
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Fallible<Tensor>
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
) -> Fallible<Tensor>
[src]
&self,
weight: Option<T>,
bias: Option<T>,
running_mean: Option<T>,
running_var: Option<T>,
training: bool,
momentum: f64,
eps: f64,
cudnn_enabled: bool
) -> Fallible<Tensor>
pub fn f_bernoulli(&self) -> Fallible<Tensor>
[src]
pub fn f_bernoulli1(&self, p: f64) -> Fallible<Tensor>
[src]
pub fn f_bernoulli_(&self, p: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_bernoulli_1(&self, p: f64) -> Fallible<Tensor>
[src]
pub fn f_bernoulli_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_bilinear<T: Borrow<Tensor>>(
input1: &Tensor,
input2: &Tensor,
weight: &Tensor,
bias: Option<T>
) -> Fallible<Tensor>
[src]
input1: &Tensor,
input2: &Tensor,
weight: &Tensor,
bias: Option<T>
) -> Fallible<Tensor>
pub fn f_binary_cross_entropy(
&self,
target: &Tensor,
weight: &Tensor,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
target: &Tensor,
weight: &Tensor,
reduction: i64
) -> Fallible<Tensor>
pub fn f_binary_cross_entropy_backward<T: Borrow<Tensor>>(
&self,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64
) -> Fallible<Tensor>
pub fn f_binary_cross_entropy_backward_out<T: Borrow<Tensor>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64
) -> Fallible<Tensor>
pub fn f_binary_cross_entropy_out(
&self,
output: &Tensor,
target: &Tensor,
weight: &Tensor,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
target: &Tensor,
weight: &Tensor,
reduction: i64
) -> Fallible<Tensor>
pub fn f_binary_cross_entropy_with_logits<T: Borrow<Tensor>>(
&self,
target: &Tensor,
weight: Option<T>,
pos_weight: Option<T>,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
target: &Tensor,
weight: Option<T>,
pos_weight: Option<T>,
reduction: i64
) -> Fallible<Tensor>
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: i64
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
pos_weight: Option<T>,
reduction: i64
) -> Fallible<Tensor>
pub fn f_bincount<T: Borrow<Tensor>>(
&self,
weights: Option<T>,
minlength: i64
) -> Fallible<Tensor>
[src]
&self,
weights: Option<T>,
minlength: i64
) -> Fallible<Tensor>
pub fn f_blackman_window(
window_length: i64,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
window_length: i64,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_blackman_window1(
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_bmm(&self, mat2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_bmm_out(&self, result: &Tensor, mat2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_btrifact(&self, pivot: bool) -> Fallible<(Tensor, Tensor)>
[src]
pub fn f_btrifact_out(
&self,
a_lu: &Tensor,
pivots: &Tensor,
pivot: bool
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
a_lu: &Tensor,
pivots: &Tensor,
pivot: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_btrifact_with_info(
&self,
pivot: bool
) -> Fallible<(Tensor, Tensor, Tensor)>
[src]
&self,
pivot: bool
) -> Fallible<(Tensor, Tensor, Tensor)>
pub fn f_btrifact_with_info_out(
&self,
a_lu: &Tensor,
pivots: &Tensor,
info: &Tensor,
pivot: bool
) -> Fallible<(Tensor, Tensor, Tensor)>
[src]
&self,
a_lu: &Tensor,
pivots: &Tensor,
info: &Tensor,
pivot: bool
) -> Fallible<(Tensor, Tensor, Tensor)>
pub fn f_btrisolve(
&self,
lu_data: &Tensor,
lu_pivots: &Tensor
) -> Fallible<Tensor>
[src]
&self,
lu_data: &Tensor,
lu_pivots: &Tensor
) -> Fallible<Tensor>
pub fn f_btrisolve_out(
&self,
result: &Tensor,
lu_data: &Tensor,
lu_pivots: &Tensor
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
lu_data: &Tensor,
lu_pivots: &Tensor
) -> Fallible<Tensor>
pub fn f_cat<T: Borrow<Tensor>>(tensors: &[T], dim: i64) -> Fallible<Tensor>
[src]
pub fn f_cat_out<T: Borrow<Tensor>>(
result: &Tensor,
tensors: &[T],
dim: i64
) -> Fallible<Tensor>
[src]
result: &Tensor,
tensors: &[T],
dim: i64
) -> Fallible<Tensor>
pub fn f_cauchy_(&self, median: f64, sigma: f64) -> Fallible<Tensor>
[src]
pub fn f_ceil(&self) -> Fallible<Tensor>
[src]
pub fn f_ceil_(&self) -> Fallible<Tensor>
[src]
pub fn f_ceil_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_celu(&self) -> Fallible<Tensor>
[src]
pub fn f_celu_(&self) -> Fallible<Tensor>
[src]
pub fn f_chain_matmul<T: Borrow<Tensor>>(matrices: &[T]) -> Fallible<Tensor>
[src]
pub fn f_cholesky(&self, upper: bool) -> Fallible<Tensor>
[src]
pub fn f_cholesky_out(&self, result: &Tensor, upper: bool) -> Fallible<Tensor>
[src]
pub fn f_clamp<S: Into<Scalar>>(&self, min: S, max: S) -> Fallible<Tensor>
[src]
pub fn f_clamp_<S: Into<Scalar>>(&self, min: S, max: S) -> Fallible<Tensor>
[src]
pub fn f_clamp_max<S: Into<Scalar>>(&self, max: S) -> Fallible<Tensor>
[src]
pub fn f_clamp_max_<S: Into<Scalar>>(&self, max: S) -> Fallible<Tensor>
[src]
pub fn f_clamp_max_out<S: Into<Scalar>>(
&self,
result: &Tensor,
max: S
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
max: S
) -> Fallible<Tensor>
pub fn f_clamp_min<S: Into<Scalar>>(&self, min: S) -> Fallible<Tensor>
[src]
pub fn f_clamp_min_<S: Into<Scalar>>(&self, min: S) -> Fallible<Tensor>
[src]
pub fn f_clamp_min_out<S: Into<Scalar>>(
&self,
result: &Tensor,
min: S
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
min: S
) -> Fallible<Tensor>
pub fn f_clamp_out<S: Into<Scalar>>(
&self,
result: &Tensor,
min: S,
max: S
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
min: S,
max: S
) -> Fallible<Tensor>
pub fn f_coalesce(&self) -> Fallible<Tensor>
[src]
pub fn f_constant_pad_nd(&self, pad: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_contiguous(&self) -> Fallible<Tensor>
[src]
pub fn f_conv1d(
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
groups: i64
) -> Fallible<Tensor>
[src]
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
groups: i64
) -> Fallible<Tensor>
pub fn f_conv2d(
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
groups: i64
) -> Fallible<Tensor>
[src]
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
groups: i64
) -> Fallible<Tensor>
pub fn f_conv3d(
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
groups: i64
) -> Fallible<Tensor>
[src]
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
groups: i64
) -> Fallible<Tensor>
pub fn f_conv_tbc(
&self,
weight: &Tensor,
bias: &Tensor,
pad: i64
) -> Fallible<Tensor>
[src]
&self,
weight: &Tensor,
bias: &Tensor,
pad: i64
) -> Fallible<Tensor>
pub fn f_conv_tbc_backward(
&self,
input: &Tensor,
weight: &Tensor,
bias: &Tensor,
pad: i64
) -> Fallible<(Tensor, Tensor, Tensor)>
[src]
&self,
input: &Tensor,
weight: &Tensor,
bias: &Tensor,
pad: i64
) -> Fallible<(Tensor, Tensor, Tensor)>
pub fn f_conv_transpose1d(
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
groups: i64,
dilation: &[i64]
) -> Fallible<Tensor>
[src]
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
groups: i64,
dilation: &[i64]
) -> Fallible<Tensor>
pub fn f_conv_transpose2d(
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
groups: i64,
dilation: &[i64]
) -> Fallible<Tensor>
[src]
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
groups: i64,
dilation: &[i64]
) -> Fallible<Tensor>
pub fn f_conv_transpose3d(
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
groups: i64,
dilation: &[i64]
) -> Fallible<Tensor>
[src]
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
groups: i64,
dilation: &[i64]
) -> Fallible<Tensor>
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
) -> Fallible<Tensor>
[src]
&self,
weight: &Tensor,
bias: Option<T>,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
transposed: bool,
output_padding: &[i64],
groups: i64
) -> Fallible<Tensor>
pub fn f_copy_sparse_to_sparse_(
&self,
src: &Tensor,
non_blocking: bool
) -> Fallible<Tensor>
[src]
&self,
src: &Tensor,
non_blocking: bool
) -> Fallible<Tensor>
pub fn f_cos(&self) -> Fallible<Tensor>
[src]
pub fn f_cos_(&self) -> Fallible<Tensor>
[src]
pub fn f_cos_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_cosh(&self) -> Fallible<Tensor>
[src]
pub fn f_cosh_(&self) -> Fallible<Tensor>
[src]
pub fn f_cosh_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_cosine_embedding_loss(
input1: &Tensor,
input2: &Tensor,
target: &Tensor,
margin: f64,
reduction: i64
) -> Fallible<Tensor>
[src]
input1: &Tensor,
input2: &Tensor,
target: &Tensor,
margin: f64,
reduction: i64
) -> Fallible<Tensor>
pub fn f_cross(&self, other: &Tensor, dim: i64) -> Fallible<Tensor>
[src]
pub fn f_cross_out(
&self,
result: &Tensor,
other: &Tensor,
dim: i64
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
other: &Tensor,
dim: i64
) -> Fallible<Tensor>
pub fn f_ctc_loss(
log_probs: &Tensor,
targets: &Tensor,
input_lengths: &[i64],
target_lengths: &[i64],
blank: i64,
reduction: i64
) -> Fallible<Tensor>
[src]
log_probs: &Tensor,
targets: &Tensor,
input_lengths: &[i64],
target_lengths: &[i64],
blank: i64,
reduction: i64
) -> Fallible<Tensor>
pub fn f_ctc_loss1(
log_probs: &Tensor,
targets: &Tensor,
input_lengths: &Tensor,
target_lengths: &Tensor,
blank: i64,
reduction: i64
) -> Fallible<Tensor>
[src]
log_probs: &Tensor,
targets: &Tensor,
input_lengths: &Tensor,
target_lengths: &Tensor,
blank: i64,
reduction: i64
) -> Fallible<Tensor>
pub fn f_cudnn_affine_grid_generator(
theta: &Tensor,
n: i64,
c: i64,
h: i64,
w: i64
) -> Fallible<Tensor>
[src]
theta: &Tensor,
n: i64,
c: i64,
h: i64,
w: i64
) -> Fallible<Tensor>
pub fn f_cudnn_affine_grid_generator_backward(
grad: &Tensor,
n: i64,
c: i64,
h: i64,
w: i64
) -> Fallible<Tensor>
[src]
grad: &Tensor,
n: i64,
c: i64,
h: i64,
w: i64
) -> Fallible<Tensor>
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
) -> Fallible<(Tensor, Tensor, Tensor)>
[src]
&self,
weight: &Tensor,
bias: Option<T>,
running_mean: Option<T>,
running_var: Option<T>,
training: bool,
exponential_average_factor: f64,
epsilon: f64
) -> Fallible<(Tensor, Tensor, Tensor)>
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
) -> Fallible<(Tensor, Tensor, Tensor)>
[src]
&self,
grad_output: &Tensor,
weight: &Tensor,
running_mean: Option<T>,
running_var: Option<T>,
save_mean: Option<T>,
save_var: Option<T>,
epsilon: f64
) -> Fallible<(Tensor, Tensor, Tensor)>
pub fn f_cudnn_convolution<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Fallible<Tensor>
[src]
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Fallible<Tensor>
pub fn f_cudnn_convolution_backward_bias(
grad_output: &Tensor
) -> Fallible<Tensor>
[src]
grad_output: &Tensor
) -> Fallible<Tensor>
pub fn f_cudnn_convolution_backward_input(
self_size: &[i64],
grad_output: &Tensor,
weight: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Fallible<Tensor>
[src]
self_size: &[i64],
grad_output: &Tensor,
weight: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Fallible<Tensor>
pub fn f_cudnn_convolution_backward_weight(
&self,
weight_size: &[i64],
grad_output: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Fallible<Tensor>
[src]
&self,
weight_size: &[i64],
grad_output: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Fallible<Tensor>
pub fn f_cudnn_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
) -> Fallible<Tensor>
[src]
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
output_padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Fallible<Tensor>
pub fn f_cudnn_convolution_transpose_backward_bias(
grad_output: &Tensor
) -> Fallible<Tensor>
[src]
grad_output: &Tensor
) -> Fallible<Tensor>
pub fn f_cudnn_convolution_transpose_backward_input(
grad_output: &Tensor,
weight: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Fallible<Tensor>
[src]
grad_output: &Tensor,
weight: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Fallible<Tensor>
pub fn f_cudnn_convolution_transpose_backward_weight(
&self,
weight_size: &[i64],
grad_output: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Fallible<Tensor>
[src]
&self,
weight_size: &[i64],
grad_output: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Fallible<Tensor>
pub fn f_cudnn_grid_sampler(&self, grid: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_cudnn_grid_sampler_backward(
&self,
grid: &Tensor,
grad_output: &Tensor
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
grid: &Tensor,
grad_output: &Tensor
) -> Fallible<(Tensor, Tensor)>
pub fn f_cumprod(&self, dim: i64) -> Fallible<Tensor>
[src]
pub fn f_cumprod1(&self, dim: i64, dtype: Kind) -> Fallible<Tensor>
[src]
pub fn f_cumprod_out(&self, result: &Tensor, dim: i64) -> Fallible<Tensor>
[src]
pub fn f_cumprod_out1(
&self,
result: &Tensor,
dim: i64,
dtype: Kind
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
dim: i64,
dtype: Kind
) -> Fallible<Tensor>
pub fn f_cumsum(&self, dim: i64) -> Fallible<Tensor>
[src]
pub fn f_cumsum1(&self, dim: i64, dtype: Kind) -> Fallible<Tensor>
[src]
pub fn f_cumsum_out(&self, result: &Tensor, dim: i64) -> Fallible<Tensor>
[src]
pub fn f_cumsum_out1(
&self,
result: &Tensor,
dim: i64,
dtype: Kind
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
dim: i64,
dtype: Kind
) -> Fallible<Tensor>
pub fn f_det(&self) -> Fallible<Tensor>
[src]
pub fn f_detach(&self) -> Fallible<Tensor>
[src]
pub fn f_detach_(&self) -> Fallible<Tensor>
[src]
pub fn f_diag(&self, diagonal: i64) -> Fallible<Tensor>
[src]
pub fn f_diag_embed(
&self,
offset: i64,
dim1: i64,
dim2: i64
) -> Fallible<Tensor>
[src]
&self,
offset: i64,
dim1: i64,
dim2: i64
) -> Fallible<Tensor>
pub fn f_diag_out(&self, result: &Tensor, diagonal: i64) -> Fallible<Tensor>
[src]
pub fn f_diagflat(&self, offset: i64) -> Fallible<Tensor>
[src]
pub fn f_diagonal(&self, offset: i64, dim1: i64, dim2: i64) -> Fallible<Tensor>
[src]
pub fn f_digamma(&self) -> Fallible<Tensor>
[src]
pub fn f_digamma_(&self) -> Fallible<Tensor>
[src]
pub fn f_digamma_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_dist(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_div(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_div1<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_div_(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_div_1<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_div_out(&self, result: &Tensor, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_dot(&self, tensor: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_dot_out(&self, result: &Tensor, tensor: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_dropout(&self, p: f64, train: bool) -> Fallible<Tensor>
[src]
pub fn f_dropout_(&self, p: f64, train: bool) -> Fallible<Tensor>
[src]
pub fn f_eig(&self, eigenvectors: bool) -> Fallible<(Tensor, Tensor)>
[src]
pub fn f_eig_out(
&self,
e: &Tensor,
v: &Tensor,
eigenvectors: bool
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
e: &Tensor,
v: &Tensor,
eigenvectors: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_elu(&self) -> Fallible<Tensor>
[src]
pub fn f_elu_(&self) -> Fallible<Tensor>
[src]
pub fn f_elu_out(&self, output: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_embedding(
weight: &Tensor,
indices: &Tensor,
padding_idx: i64,
scale_grad_by_freq: bool,
sparse: bool
) -> Fallible<Tensor>
[src]
weight: &Tensor,
indices: &Tensor,
padding_idx: i64,
scale_grad_by_freq: bool,
sparse: bool
) -> Fallible<Tensor>
pub fn f_embedding_backward(
grad: &Tensor,
indices: &Tensor,
num_weights: i64,
padding_idx: i64,
scale_grad_by_freq: bool,
sparse: bool
) -> Fallible<Tensor>
[src]
grad: &Tensor,
indices: &Tensor,
num_weights: i64,
padding_idx: i64,
scale_grad_by_freq: bool,
sparse: bool
) -> Fallible<Tensor>
pub fn f_embedding_bag(
weight: &Tensor,
indices: &Tensor,
offsets: &Tensor,
scale_grad_by_freq: bool,
mode: i64,
sparse: bool
) -> Fallible<(Tensor, Tensor, Tensor, Tensor)>
[src]
weight: &Tensor,
indices: &Tensor,
offsets: &Tensor,
scale_grad_by_freq: bool,
mode: i64,
sparse: bool
) -> Fallible<(Tensor, Tensor, Tensor, Tensor)>
pub fn f_embedding_dense_backward(
grad: &Tensor,
indices: &Tensor,
num_weights: i64,
padding_idx: i64,
scale_grad_by_freq: bool
) -> Fallible<Tensor>
[src]
grad: &Tensor,
indices: &Tensor,
num_weights: i64,
padding_idx: i64,
scale_grad_by_freq: bool
) -> Fallible<Tensor>
pub fn f_embedding_renorm_(
&self,
indices: &Tensor,
max_norm: f64,
norm_type: f64
) -> Fallible<Tensor>
[src]
&self,
indices: &Tensor,
max_norm: f64,
norm_type: f64
) -> Fallible<Tensor>
pub fn f_embedding_sparse_backward(
grad: &Tensor,
indices: &Tensor,
num_weights: i64,
padding_idx: i64,
scale_grad_by_freq: bool
) -> Fallible<Tensor>
[src]
grad: &Tensor,
indices: &Tensor,
num_weights: i64,
padding_idx: i64,
scale_grad_by_freq: bool
) -> Fallible<Tensor>
pub fn f_empty(size: &[i64], options: (Kind, Device)) -> Fallible<Tensor>
[src]
pub fn f_empty_like(&self) -> Fallible<Tensor>
[src]
pub fn f_empty_like1(&self, options: (Kind, Device)) -> Fallible<Tensor>
[src]
pub fn f_empty_out(result: &Tensor, size: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_empty_strided(
size: &[i64],
stride: &[i64],
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
size: &[i64],
stride: &[i64],
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_eq<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_eq1(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_eq_<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_eq_1(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_eq_out<S: Into<Scalar>>(
&self,
result: &Tensor,
other: S
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
other: S
) -> Fallible<Tensor>
pub fn f_eq_out1(&self, result: &Tensor, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_erf(&self) -> Fallible<Tensor>
[src]
pub fn f_erf_(&self) -> Fallible<Tensor>
[src]
pub fn f_erf_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_erfc(&self) -> Fallible<Tensor>
[src]
pub fn f_erfc_(&self) -> Fallible<Tensor>
[src]
pub fn f_erfc_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_erfinv(&self) -> Fallible<Tensor>
[src]
pub fn f_erfinv_(&self) -> Fallible<Tensor>
[src]
pub fn f_erfinv_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_exp(&self) -> Fallible<Tensor>
[src]
pub fn f_exp_(&self) -> Fallible<Tensor>
[src]
pub fn f_exp_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_expand(&self, size: &[i64], implicit: bool) -> Fallible<Tensor>
[src]
pub fn f_expand_as(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_expm1(&self) -> Fallible<Tensor>
[src]
pub fn f_expm1_(&self) -> Fallible<Tensor>
[src]
pub fn f_expm1_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_exponential_(&self, lambd: f64) -> Fallible<Tensor>
[src]
pub fn f_eye(n: i64, options: (Kind, Device)) -> Fallible<Tensor>
[src]
pub fn f_eye1(n: i64, m: i64, options: (Kind, Device)) -> Fallible<Tensor>
[src]
pub fn f_eye_out(result: &Tensor, n: i64) -> Fallible<Tensor>
[src]
pub fn f_eye_out1(result: &Tensor, n: i64, m: i64) -> Fallible<Tensor>
[src]
pub fn f_feature_alpha_dropout(&self, p: f64, train: bool) -> Fallible<Tensor>
[src]
pub fn f_feature_alpha_dropout_(&self, p: f64, train: bool) -> Fallible<Tensor>
[src]
pub fn f_feature_dropout(&self, p: f64, train: bool) -> Fallible<Tensor>
[src]
pub fn f_feature_dropout_(&self, p: f64, train: bool) -> Fallible<Tensor>
[src]
pub fn f_fft(&self, signal_ndim: i64, normalized: bool) -> Fallible<Tensor>
[src]
pub fn f_fill_<S: Into<Scalar>>(&self, value: S) -> Fallible<Tensor>
[src]
pub fn f_fill_1(&self, value: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_flatten(&self, start_dim: i64, end_dim: i64) -> Fallible<Tensor>
[src]
pub fn f_flip(&self, dims: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_floor(&self) -> Fallible<Tensor>
[src]
pub fn f_floor_(&self) -> Fallible<Tensor>
[src]
pub fn f_floor_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_fmod<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_fmod1(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_fmod_<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_fmod_1(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_fmod_out<S: Into<Scalar>>(
&self,
result: &Tensor,
other: S
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
other: S
) -> Fallible<Tensor>
pub fn f_fmod_out1(&self, result: &Tensor, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_frac(&self) -> Fallible<Tensor>
[src]
pub fn f_frac_(&self) -> Fallible<Tensor>
[src]
pub fn f_frac_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_fractional_max_pool2d(
&self,
kernel_size: &[i64],
output_size: &[i64],
random_samples: &Tensor
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
kernel_size: &[i64],
output_size: &[i64],
random_samples: &Tensor
) -> Fallible<(Tensor, Tensor)>
pub fn f_fractional_max_pool2d_backward(
&self,
grad_output: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
indices: &Tensor
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
indices: &Tensor
) -> Fallible<Tensor>
pub fn f_fractional_max_pool2d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
indices: &Tensor
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
indices: &Tensor
) -> Fallible<Tensor>
pub fn f_fractional_max_pool2d_out(
&self,
output: &Tensor,
indices: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
random_samples: &Tensor
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
output: &Tensor,
indices: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
random_samples: &Tensor
) -> Fallible<(Tensor, Tensor)>
pub fn f_frobenius_norm(&self) -> Fallible<Tensor>
[src]
pub fn f_frobenius_norm1(&self, dim: &[i64], keepdim: bool) -> Fallible<Tensor>
[src]
pub fn f_frobenius_norm_out(
&self,
result: &Tensor,
dim: &[i64],
keepdim: bool
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
dim: &[i64],
keepdim: bool
) -> Fallible<Tensor>
pub fn f_full<S: Into<Scalar>>(
size: &[i64],
fill_value: S,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
size: &[i64],
fill_value: S,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_full_like<S: Into<Scalar>>(&self, fill_value: S) -> Fallible<Tensor>
[src]
pub fn f_full_like1<S: Into<Scalar>>(
&self,
fill_value: S,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
&self,
fill_value: S,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_full_out<S: Into<Scalar>>(
result: &Tensor,
size: &[i64],
fill_value: S
) -> Fallible<Tensor>
[src]
result: &Tensor,
size: &[i64],
fill_value: S
) -> Fallible<Tensor>
pub fn f_gather(&self, dim: i64, index: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_gather_out(
&self,
result: &Tensor,
dim: i64,
index: &Tensor
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
dim: i64,
index: &Tensor
) -> Fallible<Tensor>
pub fn f_ge<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_ge1(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_ge_<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_ge_1(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_ge_out<S: Into<Scalar>>(
&self,
result: &Tensor,
other: S
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
other: S
) -> Fallible<Tensor>
pub fn f_ge_out1(&self, result: &Tensor, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_gels(&self, a: &Tensor) -> Fallible<(Tensor, Tensor)>
[src]
pub fn f_gels_out(
&self,
x: &Tensor,
qr: &Tensor,
a: &Tensor
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
x: &Tensor,
qr: &Tensor,
a: &Tensor
) -> Fallible<(Tensor, Tensor)>
pub fn f_geometric_(&self, p: f64) -> Fallible<Tensor>
[src]
pub fn f_geqrf(&self) -> Fallible<(Tensor, Tensor)>
[src]
pub fn f_geqrf_out(
&self,
result0: &Tensor,
result1: &Tensor
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
result0: &Tensor,
result1: &Tensor
) -> Fallible<(Tensor, Tensor)>
pub fn f_ger(&self, vec2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_ger_out(&self, result: &Tensor, vec2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_gesv(&self, a: &Tensor) -> Fallible<(Tensor, Tensor)>
[src]
pub fn f_gesv_out(
&self,
solution: &Tensor,
lu: &Tensor,
a: &Tensor
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
solution: &Tensor,
lu: &Tensor,
a: &Tensor
) -> Fallible<(Tensor, Tensor)>
pub fn f_glu(&self, dim: i64) -> Fallible<Tensor>
[src]
pub fn f_glu_backward(&self, grad_output: &Tensor, dim: i64) -> Fallible<Tensor>
[src]
pub fn f_glu_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
dim: i64
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
dim: i64
) -> Fallible<Tensor>
pub fn f_glu_out(&self, output: &Tensor, dim: i64) -> Fallible<Tensor>
[src]
pub fn f_grad(&self) -> Fallible<Tensor>
[src]
pub fn f_grid_sampler(
&self,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64
) -> Fallible<Tensor>
[src]
&self,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64
) -> Fallible<Tensor>
pub fn f_grid_sampler_2d(
&self,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64
) -> Fallible<Tensor>
[src]
&self,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64
) -> Fallible<Tensor>
pub fn f_grid_sampler_2d_backward(
&self,
grad_output: &Tensor,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
grad_output: &Tensor,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64
) -> Fallible<(Tensor, Tensor)>
pub fn f_grid_sampler_3d(
&self,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64
) -> Fallible<Tensor>
[src]
&self,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64
) -> Fallible<Tensor>
pub fn f_grid_sampler_3d_backward(
&self,
grad_output: &Tensor,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
grad_output: &Tensor,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64
) -> Fallible<(Tensor, Tensor)>
pub fn f_group_norm<T: Borrow<Tensor>>(
&self,
num_groups: i64,
weight: Option<T>,
bias: Option<T>,
eps: f64,
cudnn_enabled: bool
) -> Fallible<Tensor>
[src]
&self,
num_groups: i64,
weight: Option<T>,
bias: Option<T>,
eps: f64,
cudnn_enabled: bool
) -> Fallible<Tensor>
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
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
hx: &Tensor,
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool,
batch_first: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_gru1<T: Borrow<Tensor>>(
data: &Tensor,
batch_sizes: &Tensor,
hx: &Tensor,
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool
) -> Fallible<(Tensor, Tensor)>
[src]
data: &Tensor,
batch_sizes: &Tensor,
hx: &Tensor,
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool
) -> Fallible<(Tensor, Tensor)>
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>
) -> Fallible<Tensor>
[src]
&self,
hx: &Tensor,
w_ih: &Tensor,
w_hh: &Tensor,
b_ih: Option<T>,
b_hh: Option<T>
) -> Fallible<Tensor>
pub fn f_gt<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_gt1(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_gt_<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_gt_1(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_gt_out<S: Into<Scalar>>(
&self,
result: &Tensor,
other: S
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
other: S
) -> Fallible<Tensor>
pub fn f_gt_out1(&self, result: &Tensor, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_hamming_window(
window_length: i64,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
window_length: i64,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_hamming_window1(
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_hamming_window2(
window_length: i64,
periodic: bool,
alpha: f64,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
window_length: i64,
periodic: bool,
alpha: f64,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_hamming_window3(
window_length: i64,
periodic: bool,
alpha: f64,
beta: f64,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
window_length: i64,
periodic: bool,
alpha: f64,
beta: f64,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_hann_window(
window_length: i64,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
window_length: i64,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_hann_window1(
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_hardshrink(&self) -> Fallible<Tensor>
[src]
pub fn f_hardshrink_backward<S: Into<Scalar>>(
&self,
grad_out: &Tensor,
lambd: S
) -> Fallible<Tensor>
[src]
&self,
grad_out: &Tensor,
lambd: S
) -> Fallible<Tensor>
pub fn f_hardtanh(&self) -> Fallible<Tensor>
[src]
pub fn f_hardtanh_(&self) -> Fallible<Tensor>
[src]
pub fn f_hardtanh_out(&self, output: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_hinge_embedding_loss(
&self,
target: &Tensor,
margin: f64,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
target: &Tensor,
margin: f64,
reduction: i64
) -> Fallible<Tensor>
pub fn f_histc(&self, bins: i64) -> Fallible<Tensor>
[src]
pub fn f_histc_out(&self, result: &Tensor, bins: i64) -> Fallible<Tensor>
[src]
pub fn f_hspmm(mat1: &Tensor, mat2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_hspmm_out(
result: &Tensor,
mat1: &Tensor,
mat2: &Tensor
) -> Fallible<Tensor>
[src]
result: &Tensor,
mat1: &Tensor,
mat2: &Tensor
) -> Fallible<Tensor>
pub fn f_ifft(&self, signal_ndim: i64, normalized: bool) -> Fallible<Tensor>
[src]
pub fn f_index<T: Borrow<Tensor>>(&self, indices: &[T]) -> Fallible<Tensor>
[src]
pub fn f_index_add_(
&self,
dim: i64,
index: &Tensor,
source: &Tensor
) -> Fallible<Tensor>
[src]
&self,
dim: i64,
index: &Tensor,
source: &Tensor
) -> Fallible<Tensor>
pub fn f_index_copy_(
&self,
dim: i64,
index: &Tensor,
source: &Tensor
) -> Fallible<Tensor>
[src]
&self,
dim: i64,
index: &Tensor,
source: &Tensor
) -> Fallible<Tensor>
pub fn f_index_fill_<S: Into<Scalar>>(
&self,
dim: i64,
index: &Tensor,
value: S
) -> Fallible<Tensor>
[src]
&self,
dim: i64,
index: &Tensor,
value: S
) -> Fallible<Tensor>
pub fn f_index_fill_1(
&self,
dim: i64,
index: &Tensor,
value: &Tensor
) -> Fallible<Tensor>
[src]
&self,
dim: i64,
index: &Tensor,
value: &Tensor
) -> Fallible<Tensor>
pub fn f_index_put<T: Borrow<Tensor>>(
&self,
indices: &[T],
values: &Tensor
) -> Fallible<Tensor>
[src]
&self,
indices: &[T],
values: &Tensor
) -> Fallible<Tensor>
pub fn f_index_put_<T: Borrow<Tensor>>(
&self,
indices: &[T],
values: &Tensor
) -> Fallible<Tensor>
[src]
&self,
indices: &[T],
values: &Tensor
) -> Fallible<Tensor>
pub fn f_index_select(&self, dim: i64, index: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_index_select_out(
&self,
result: &Tensor,
dim: i64,
index: &Tensor
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
dim: i64,
index: &Tensor
) -> Fallible<Tensor>
pub fn f_indices(&self) -> Fallible<Tensor>
[src]
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
) -> Fallible<Tensor>
[src]
&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
) -> Fallible<Tensor>
pub fn f_inverse(&self) -> Fallible<Tensor>
[src]
pub fn f_inverse_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_irfft(
&self,
signal_ndim: i64,
normalized: bool,
onesided: bool,
signal_sizes: &[i64]
) -> Fallible<Tensor>
[src]
&self,
signal_ndim: i64,
normalized: bool,
onesided: bool,
signal_sizes: &[i64]
) -> Fallible<Tensor>
pub fn f_isclose(
&self,
other: &Tensor,
rtol: f64,
atol: f64,
equal_nan: bool
) -> Fallible<Tensor>
[src]
&self,
other: &Tensor,
rtol: f64,
atol: f64,
equal_nan: bool
) -> Fallible<Tensor>
pub fn f_kl_div(&self, target: &Tensor, reduction: i64) -> Fallible<Tensor>
[src]
pub fn f_kl_div_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
pub fn f_kthvalue(
&self,
k: i64,
dim: i64,
keepdim: bool
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
k: i64,
dim: i64,
keepdim: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_kthvalue_out(
&self,
values: &Tensor,
indices: &Tensor,
k: i64,
dim: i64,
keepdim: bool
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
values: &Tensor,
indices: &Tensor,
k: i64,
dim: i64,
keepdim: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_l1_loss(&self, target: &Tensor, reduction: i64) -> Fallible<Tensor>
[src]
pub fn f_l1_loss_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
pub fn f_l1_loss_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
pub fn f_l1_loss_out(
&self,
output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
pub fn f_layer_norm<T: Borrow<Tensor>>(
&self,
normalized_shape: &[i64],
weight: Option<T>,
bias: Option<T>,
eps: f64,
cudnn_enable: bool
) -> Fallible<Tensor>
[src]
&self,
normalized_shape: &[i64],
weight: Option<T>,
bias: Option<T>,
eps: f64,
cudnn_enable: bool
) -> Fallible<Tensor>
pub fn f_le<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_le1(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_le_<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_le_1(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_le_out<S: Into<Scalar>>(
&self,
result: &Tensor,
other: S
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
other: S
) -> Fallible<Tensor>
pub fn f_le_out1(&self, result: &Tensor, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_leaky_relu(&self) -> Fallible<Tensor>
[src]
pub fn f_leaky_relu_(&self) -> Fallible<Tensor>
[src]
pub fn f_leaky_relu_out(&self, output: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_lerp<S: Into<Scalar>>(
&self,
end_: &Tensor,
weight: S
) -> Fallible<Tensor>
[src]
&self,
end_: &Tensor,
weight: S
) -> Fallible<Tensor>
pub fn f_lerp_<S: Into<Scalar>>(
&self,
end_: &Tensor,
weight: S
) -> Fallible<Tensor>
[src]
&self,
end_: &Tensor,
weight: S
) -> Fallible<Tensor>
pub fn f_lerp_out<S: Into<Scalar>>(
&self,
result: &Tensor,
end_: &Tensor,
weight: S
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
end_: &Tensor,
weight: S
) -> Fallible<Tensor>
pub fn f_lgamma(&self) -> Fallible<Tensor>
[src]
pub fn f_lgamma_(&self) -> Fallible<Tensor>
[src]
pub fn f_lgamma_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_linear(&self, weight: &Tensor, bias: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_linspace<S: Into<Scalar>>(
start: S,
end_: S,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
start: S,
end_: S,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_linspace1<S: Into<Scalar>>(
start: S,
end_: S,
steps: i64,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
start: S,
end_: S,
steps: i64,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_linspace_out<S: Into<Scalar>>(
result: &Tensor,
start: S,
end_: S
) -> Fallible<Tensor>
[src]
result: &Tensor,
start: S,
end_: S
) -> Fallible<Tensor>
pub fn f_linspace_out1<S: Into<Scalar>>(
result: &Tensor,
start: S,
end_: S,
steps: i64
) -> Fallible<Tensor>
[src]
result: &Tensor,
start: S,
end_: S,
steps: i64
) -> Fallible<Tensor>
pub fn f_log(&self) -> Fallible<Tensor>
[src]
pub fn f_log10(&self) -> Fallible<Tensor>
[src]
pub fn f_log10_(&self) -> Fallible<Tensor>
[src]
pub fn f_log10_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_log1p(&self) -> Fallible<Tensor>
[src]
pub fn f_log1p_(&self) -> Fallible<Tensor>
[src]
pub fn f_log1p_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_log2(&self) -> Fallible<Tensor>
[src]
pub fn f_log2_(&self) -> Fallible<Tensor>
[src]
pub fn f_log2_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_log_(&self) -> Fallible<Tensor>
[src]
pub fn f_log_normal_(&self, mean: f64, std: f64) -> Fallible<Tensor>
[src]
pub fn f_log_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_log_sigmoid(&self) -> Fallible<Tensor>
[src]
pub fn f_log_sigmoid_backward(
&self,
grad_output: &Tensor,
buffer: &Tensor
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
buffer: &Tensor
) -> Fallible<Tensor>
pub fn f_log_sigmoid_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
buffer: &Tensor
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
buffer: &Tensor
) -> Fallible<Tensor>
pub fn f_log_sigmoid_out(&self, output: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_log_softmax(&self, dim: i64) -> Fallible<Tensor>
[src]
pub fn f_log_softmax1(&self, dim: i64, dtype: Kind) -> Fallible<Tensor>
[src]
pub fn f_logdet(&self) -> Fallible<Tensor>
[src]
pub fn f_logspace<S: Into<Scalar>>(
start: S,
end_: S,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
start: S,
end_: S,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_logspace1<S: Into<Scalar>>(
start: S,
end_: S,
steps: i64,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
start: S,
end_: S,
steps: i64,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_logspace_out<S: Into<Scalar>>(
result: &Tensor,
start: S,
end_: S
) -> Fallible<Tensor>
[src]
result: &Tensor,
start: S,
end_: S
) -> Fallible<Tensor>
pub fn f_logspace_out1<S: Into<Scalar>>(
result: &Tensor,
start: S,
end_: S,
steps: i64
) -> Fallible<Tensor>
[src]
result: &Tensor,
start: S,
end_: S,
steps: i64
) -> Fallible<Tensor>
pub fn f_logsumexp(&self, dim: i64, keepdim: bool) -> Fallible<Tensor>
[src]
pub fn f_logsumexp_out(
&self,
result: &Tensor,
dim: i64,
keepdim: bool
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
dim: i64,
keepdim: bool
) -> Fallible<Tensor>
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
) -> Fallible<(Tensor, Tensor, Tensor)>
[src]
&self,
hx: &[T],
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool,
batch_first: bool
) -> Fallible<(Tensor, Tensor, Tensor)>
pub fn f_lstm1<T: Borrow<Tensor>>(
data: &Tensor,
batch_sizes: &Tensor,
hx: &[T],
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool
) -> Fallible<(Tensor, Tensor, Tensor)>
[src]
data: &Tensor,
batch_sizes: &Tensor,
hx: &[T],
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool
) -> Fallible<(Tensor, Tensor, Tensor)>
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>
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
hx: &[T],
w_ih: &Tensor,
w_hh: &Tensor,
b_ih: Option<T>,
b_hh: Option<T>
) -> Fallible<(Tensor, Tensor)>
pub fn f_lt<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_lt1(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_lt_<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_lt_1(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_lt_out<S: Into<Scalar>>(
&self,
result: &Tensor,
other: S
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
other: S
) -> Fallible<Tensor>
pub fn f_lt_out1(&self, result: &Tensor, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_margin_ranking_loss(
input1: &Tensor,
input2: &Tensor,
target: &Tensor,
margin: f64,
reduction: i64
) -> Fallible<Tensor>
[src]
input1: &Tensor,
input2: &Tensor,
target: &Tensor,
margin: f64,
reduction: i64
) -> Fallible<Tensor>
pub fn f_masked_fill_<S: Into<Scalar>>(
&self,
mask: &Tensor,
value: S
) -> Fallible<Tensor>
[src]
&self,
mask: &Tensor,
value: S
) -> Fallible<Tensor>
pub fn f_masked_fill_1(&self, mask: &Tensor, value: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_masked_scatter_(
&self,
mask: &Tensor,
source: &Tensor
) -> Fallible<Tensor>
[src]
&self,
mask: &Tensor,
source: &Tensor
) -> Fallible<Tensor>
pub fn f_masked_select(&self, mask: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_masked_select_out(
&self,
result: &Tensor,
mask: &Tensor
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
mask: &Tensor
) -> Fallible<Tensor>
pub fn f_matmul(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_matmul_out(&self, result: &Tensor, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_matrix_power(&self, n: i64) -> Fallible<Tensor>
[src]
pub fn f_matrix_rank(&self, symmetric: bool) -> Fallible<Tensor>
[src]
pub fn f_matrix_rank1(&self, tol: f64, symmetric: bool) -> Fallible<Tensor>
[src]
pub fn f_max(&self) -> Fallible<Tensor>
[src]
pub fn f_max1(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_max2(&self, dim: i64, keepdim: bool) -> Fallible<(Tensor, Tensor)>
[src]
pub fn f_max_out(&self, result: &Tensor, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_max_out1(
&self,
max: &Tensor,
max_values: &Tensor,
dim: i64,
keepdim: bool
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
max: &Tensor,
max_values: &Tensor,
dim: i64,
keepdim: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_max_pool1d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Fallible<Tensor>
[src]
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Fallible<Tensor>
pub fn f_max_pool1d_with_indices(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_max_pool2d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Fallible<Tensor>
[src]
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Fallible<Tensor>
pub fn f_max_pool2d_with_indices(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Fallible<(Tensor, Tensor)>
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
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool,
indices: &Tensor
) -> Fallible<Tensor>
pub fn f_max_pool2d_with_indices_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool,
indices: &Tensor
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool,
indices: &Tensor
) -> Fallible<Tensor>
pub fn f_max_pool2d_with_indices_out(
&self,
output: &Tensor,
indices: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
output: &Tensor,
indices: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_max_pool3d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Fallible<Tensor>
[src]
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Fallible<Tensor>
pub fn f_max_pool3d_with_indices(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Fallible<(Tensor, Tensor)>
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
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool,
indices: &Tensor
) -> Fallible<Tensor>
pub fn f_max_pool3d_with_indices_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool,
indices: &Tensor
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool,
indices: &Tensor
) -> Fallible<Tensor>
pub fn f_max_pool3d_with_indices_out(
&self,
output: &Tensor,
indices: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
output: &Tensor,
indices: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_max_unpool2d(
&self,
indices: &Tensor,
output_size: &[i64]
) -> Fallible<Tensor>
[src]
&self,
indices: &Tensor,
output_size: &[i64]
) -> Fallible<Tensor>
pub fn f_max_unpool2d_backward(
&self,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Fallible<Tensor>
pub fn f_max_unpool2d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Fallible<Tensor>
pub fn f_max_unpool2d_out(
&self,
output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Fallible<Tensor>
pub fn f_max_unpool3d(
&self,
indices: &Tensor,
output_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Fallible<Tensor>
[src]
&self,
indices: &Tensor,
output_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Fallible<Tensor>
pub fn f_max_unpool3d_backward(
&self,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Fallible<Tensor>
pub fn f_max_unpool3d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Fallible<Tensor>
pub fn f_max_unpool3d_out(
&self,
output: &Tensor,
indices: &Tensor,
output_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
indices: &Tensor,
output_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Fallible<Tensor>
pub fn f_max_values(&self, dim: i64, keepdim: bool) -> Fallible<Tensor>
[src]
pub fn f_mean(&self) -> Fallible<Tensor>
[src]
pub fn f_mean1(&self, dtype: Kind) -> Fallible<Tensor>
[src]
pub fn f_mean2(&self, dim: i64, keepdim: bool) -> Fallible<Tensor>
[src]
pub fn f_mean3(&self, dim: i64, dtype: Kind) -> Fallible<Tensor>
[src]
pub fn f_mean4(&self, dim: i64, keepdim: bool, dtype: Kind) -> Fallible<Tensor>
[src]
pub fn f_mean_out(
&self,
result: &Tensor,
dim: i64,
keepdim: bool
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
dim: i64,
keepdim: bool
) -> Fallible<Tensor>
pub fn f_mean_out1(
&self,
result: &Tensor,
dim: i64,
dtype: Kind
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
dim: i64,
dtype: Kind
) -> Fallible<Tensor>
pub fn f_mean_out2(
&self,
result: &Tensor,
dim: i64,
keepdim: bool,
dtype: Kind
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
dim: i64,
keepdim: bool,
dtype: Kind
) -> Fallible<Tensor>
pub fn f_median(&self) -> Fallible<Tensor>
[src]
pub fn f_median1(&self, dim: i64, keepdim: bool) -> Fallible<(Tensor, Tensor)>
[src]
pub fn f_median_out(
&self,
values: &Tensor,
indices: &Tensor,
dim: i64,
keepdim: bool
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
values: &Tensor,
indices: &Tensor,
dim: i64,
keepdim: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_min(&self) -> Fallible<Tensor>
[src]
pub fn f_min1(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_min2(&self, dim: i64, keepdim: bool) -> Fallible<(Tensor, Tensor)>
[src]
pub fn f_min_out(&self, result: &Tensor, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_min_out1(
&self,
min: &Tensor,
min_indices: &Tensor,
dim: i64,
keepdim: bool
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
min: &Tensor,
min_indices: &Tensor,
dim: i64,
keepdim: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_min_values(&self, dim: i64, keepdim: bool) -> Fallible<Tensor>
[src]
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
) -> Fallible<(Tensor, Tensor, Tensor)>
[src]
&self,
weight: &Tensor,
bias: Option<T>,
running_mean: Option<T>,
running_var: Option<T>,
training: bool,
exponential_average_factor: f64,
epsilon: f64
) -> Fallible<(Tensor, Tensor, Tensor)>
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
) -> Fallible<(Tensor, Tensor, Tensor)>
[src]
&self,
grad_output: &Tensor,
weight: &Tensor,
running_mean: Option<T>,
running_var: Option<T>,
save_mean: Option<T>,
save_var: Option<T>,
epsilon: f64
) -> Fallible<(Tensor, Tensor, Tensor)>
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
) -> Fallible<Tensor>
[src]
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Fallible<Tensor>
pub fn f_miopen_convolution_backward_bias(
grad_output: &Tensor
) -> Fallible<Tensor>
[src]
grad_output: &Tensor
) -> Fallible<Tensor>
pub fn f_miopen_convolution_backward_input(
self_size: &[i64],
grad_output: &Tensor,
weight: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Fallible<Tensor>
[src]
self_size: &[i64],
grad_output: &Tensor,
weight: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Fallible<Tensor>
pub fn f_miopen_convolution_backward_weight(
&self,
weight_size: &[i64],
grad_output: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Fallible<Tensor>
[src]
&self,
weight_size: &[i64],
grad_output: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Fallible<Tensor>
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
) -> Fallible<Tensor>
[src]
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
output_padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Fallible<Tensor>
pub fn f_miopen_convolution_transpose_backward_input(
grad_output: &Tensor,
weight: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Fallible<Tensor>
[src]
grad_output: &Tensor,
weight: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Fallible<Tensor>
pub fn f_miopen_convolution_transpose_backward_weight(
&self,
weight_size: &[i64],
grad_output: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Fallible<Tensor>
[src]
&self,
weight_size: &[i64],
grad_output: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Fallible<Tensor>
pub fn f_mkldnn_convolution<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64
) -> Fallible<Tensor>
[src]
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64
) -> Fallible<Tensor>
pub fn f_mkldnn_convolution_backward_input(
self_size: &[i64],
grad_output: &Tensor,
weight: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
bias_defined: bool
) -> Fallible<Tensor>
[src]
self_size: &[i64],
grad_output: &Tensor,
weight: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
bias_defined: bool
) -> Fallible<Tensor>
pub fn f_mkldnn_convolution_backward_weights(
&self,
weight_size: &[i64],
grad_output: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
bias_defined: bool
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
weight_size: &[i64],
grad_output: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
bias_defined: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_mm(&self, mat2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_mm_out(&self, result: &Tensor, mat2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_mode(&self, dim: i64, keepdim: bool) -> Fallible<(Tensor, Tensor)>
[src]
pub fn f_mode_out(
&self,
values: &Tensor,
indices: &Tensor,
dim: i64,
keepdim: bool
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
values: &Tensor,
indices: &Tensor,
dim: i64,
keepdim: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_mse_loss(&self, target: &Tensor, reduction: i64) -> Fallible<Tensor>
[src]
pub fn f_mse_loss_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
pub fn f_mse_loss_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
pub fn f_mse_loss_out(
&self,
output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
pub fn f_mul(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_mul1<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_mul_(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_mul_1<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_mul_out(&self, result: &Tensor, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_multilabel_margin_loss(
&self,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
pub fn f_multilabel_margin_loss_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64,
is_target: &Tensor
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64,
is_target: &Tensor
) -> Fallible<Tensor>
pub fn f_multilabel_margin_loss_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: i64,
is_target: &Tensor
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: i64,
is_target: &Tensor
) -> Fallible<Tensor>
pub fn f_multilabel_margin_loss_out(
&self,
output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
pub fn f_multinomial(
&self,
num_samples: i64,
replacement: bool
) -> Fallible<Tensor>
[src]
&self,
num_samples: i64,
replacement: bool
) -> Fallible<Tensor>
pub fn f_multinomial_out(
&self,
result: &Tensor,
num_samples: i64,
replacement: bool
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
num_samples: i64,
replacement: bool
) -> Fallible<Tensor>
pub fn f_mv(&self, vec: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_mv_out(&self, result: &Tensor, vec: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_mvlgamma(&self, p: i64) -> Fallible<Tensor>
[src]
pub fn f_mvlgamma_(&self, p: i64) -> Fallible<Tensor>
[src]
pub fn f_narrow(&self, dim: i64, start: i64, length: i64) -> Fallible<Tensor>
[src]
pub fn f_narrow_copy(
&self,
dim: i64,
start: i64,
length: i64
) -> Fallible<Tensor>
[src]
&self,
dim: i64,
start: i64,
length: i64
) -> Fallible<Tensor>
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
) -> Fallible<(Tensor, Tensor, Tensor)>
[src]
&self,
weight: Option<T>,
bias: Option<T>,
running_mean: Option<T>,
running_var: Option<T>,
training: bool,
momentum: f64,
eps: f64
) -> Fallible<(Tensor, Tensor, Tensor)>
pub fn f_native_clone(&self) -> Fallible<Tensor>
[src]
pub fn f_native_norm(&self) -> Fallible<Tensor>
[src]
pub fn f_native_pow<S: Into<Scalar>>(&self, exponent: S) -> Fallible<Tensor>
[src]
pub fn f_native_pow_out<S: Into<Scalar>>(
&self,
result: &Tensor,
exponent: S
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
exponent: S
) -> Fallible<Tensor>
pub fn f_native_resize_as_(&self, the_template: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_native_zero_(&self) -> Fallible<Tensor>
[src]
pub fn f_ne<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_ne1(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_ne_<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_ne_1(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_ne_out<S: Into<Scalar>>(
&self,
result: &Tensor,
other: S
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
other: S
) -> Fallible<Tensor>
pub fn f_ne_out1(&self, result: &Tensor, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_neg(&self) -> Fallible<Tensor>
[src]
pub fn f_neg_(&self) -> Fallible<Tensor>
[src]
pub fn f_neg_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_nll_loss(
&self,
target: &Tensor,
weight: &Tensor,
reduction: i64,
ignore_index: i64
) -> Fallible<Tensor>
[src]
&self,
target: &Tensor,
weight: &Tensor,
reduction: i64,
ignore_index: i64
) -> Fallible<Tensor>
pub fn f_nll_loss2d(
&self,
target: &Tensor,
weight: &Tensor,
reduction: i64,
ignore_index: i64
) -> Fallible<Tensor>
[src]
&self,
target: &Tensor,
weight: &Tensor,
reduction: i64,
ignore_index: i64
) -> Fallible<Tensor>
pub fn f_nll_loss2d_backward<T: Borrow<Tensor>>(
&self,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64,
ignore_index: i64,
total_weight: &Tensor
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64,
ignore_index: i64,
total_weight: &Tensor
) -> Fallible<Tensor>
pub fn f_nll_loss2d_backward_out<T: Borrow<Tensor>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64,
ignore_index: i64,
total_weight: &Tensor
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64,
ignore_index: i64,
total_weight: &Tensor
) -> Fallible<Tensor>
pub fn f_nll_loss2d_out(
&self,
output: &Tensor,
target: &Tensor,
weight: &Tensor,
reduction: i64,
ignore_index: i64
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
target: &Tensor,
weight: &Tensor,
reduction: i64,
ignore_index: i64
) -> Fallible<Tensor>
pub fn f_nll_loss_backward<T: Borrow<Tensor>>(
&self,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64,
ignore_index: i64,
total_weight: &Tensor
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64,
ignore_index: i64,
total_weight: &Tensor
) -> Fallible<Tensor>
pub fn f_nll_loss_backward_out<T: Borrow<Tensor>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64,
ignore_index: i64,
total_weight: &Tensor
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64,
ignore_index: i64,
total_weight: &Tensor
) -> Fallible<Tensor>
pub fn f_nll_loss_out(
&self,
output: &Tensor,
target: &Tensor,
weight: &Tensor,
reduction: i64,
ignore_index: i64
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
target: &Tensor,
weight: &Tensor,
reduction: i64,
ignore_index: i64
) -> Fallible<Tensor>
pub fn f_nonzero(&self) -> Fallible<Tensor>
[src]
pub fn f_nonzero_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_norm(&self) -> Fallible<Tensor>
[src]
pub fn f_norm1<S: Into<Scalar>>(
&self,
p: S,
dim: i64,
keepdim: bool
) -> Fallible<Tensor>
[src]
&self,
p: S,
dim: i64,
keepdim: bool
) -> Fallible<Tensor>
pub fn f_norm_except_dim(v: &Tensor, pow: i64, dim: i64) -> Fallible<Tensor>
[src]
pub fn f_norm_out<S: Into<Scalar>>(
&self,
result: &Tensor,
p: S,
dim: i64,
keepdim: bool
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
p: S,
dim: i64,
keepdim: bool
) -> Fallible<Tensor>
pub fn f_normal(mean: &Tensor, std: f64) -> Fallible<Tensor>
[src]
pub fn f_normal1(mean: f64, std: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_normal2(mean: &Tensor, std: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_normal_(&self, mean: f64, std: f64) -> Fallible<Tensor>
[src]
pub fn f_normal_out(
output: &Tensor,
mean: &Tensor,
std: f64
) -> Fallible<Tensor>
[src]
output: &Tensor,
mean: &Tensor,
std: f64
) -> Fallible<Tensor>
pub fn f_normal_out1(
output: &Tensor,
mean: f64,
std: &Tensor
) -> Fallible<Tensor>
[src]
output: &Tensor,
mean: f64,
std: &Tensor
) -> Fallible<Tensor>
pub fn f_normal_out2(
output: &Tensor,
mean: &Tensor,
std: &Tensor
) -> Fallible<Tensor>
[src]
output: &Tensor,
mean: &Tensor,
std: &Tensor
) -> Fallible<Tensor>
pub fn f_nuclear_norm(&self, keepdim: bool) -> Fallible<Tensor>
[src]
pub fn f_nuclear_norm_out(
&self,
result: &Tensor,
keepdim: bool
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
keepdim: bool
) -> Fallible<Tensor>
pub fn f_ones(size: &[i64], options: (Kind, Device)) -> Fallible<Tensor>
[src]
pub fn f_ones_like(&self) -> Fallible<Tensor>
[src]
pub fn f_ones_like1(&self, options: (Kind, Device)) -> Fallible<Tensor>
[src]
pub fn f_ones_out(result: &Tensor, size: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_orgqr(&self, input2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_orgqr_out(&self, result: &Tensor, input2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_ormqr(
&self,
input2: &Tensor,
input3: &Tensor,
left: bool,
transpose: bool
) -> Fallible<Tensor>
[src]
&self,
input2: &Tensor,
input3: &Tensor,
left: bool,
transpose: bool
) -> Fallible<Tensor>
pub fn f_ormqr_out(
&self,
result: &Tensor,
input2: &Tensor,
input3: &Tensor,
left: bool,
transpose: bool
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
input2: &Tensor,
input3: &Tensor,
left: bool,
transpose: bool
) -> Fallible<Tensor>
pub fn f_pairwise_distance(
x1: &Tensor,
x2: &Tensor,
p: f64,
eps: f64,
keepdim: bool
) -> Fallible<Tensor>
[src]
x1: &Tensor,
x2: &Tensor,
p: f64,
eps: f64,
keepdim: bool
) -> Fallible<Tensor>
pub fn f_pdist(&self, p: f64) -> Fallible<Tensor>
[src]
pub fn f_permute(&self, dims: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_pin_memory(&self) -> Fallible<Tensor>
[src]
pub fn f_pinverse(&self, rcond: f64) -> Fallible<Tensor>
[src]
pub fn f_pixel_shuffle(&self, upscale_factor: i64) -> Fallible<Tensor>
[src]
pub fn f_poisson(&self) -> Fallible<Tensor>
[src]
pub fn f_polygamma(&self, n: i64) -> Fallible<Tensor>
[src]
pub fn f_polygamma_(&self, n: i64) -> Fallible<Tensor>
[src]
pub fn f_polygamma_out(&self, result: &Tensor, n: i64) -> Fallible<Tensor>
[src]
pub fn f_potri(&self, upper: bool) -> Fallible<Tensor>
[src]
pub fn f_potri_out(&self, result: &Tensor, upper: bool) -> Fallible<Tensor>
[src]
pub fn f_potrs(&self, input2: &Tensor, upper: bool) -> Fallible<Tensor>
[src]
pub fn f_potrs_out(
&self,
result: &Tensor,
input2: &Tensor,
upper: bool
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
input2: &Tensor,
upper: bool
) -> Fallible<Tensor>
pub fn f_pow<S: Into<Scalar>>(&self, exponent: S) -> Fallible<Tensor>
[src]
pub fn f_pow1(&self, exponent: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_pow2<S: Into<Scalar>>(
self_scalar: S,
exponent: &Tensor
) -> Fallible<Tensor>
[src]
self_scalar: S,
exponent: &Tensor
) -> Fallible<Tensor>
pub fn f_pow_<S: Into<Scalar>>(&self, exponent: S) -> Fallible<Tensor>
[src]
pub fn f_pow_1(&self, exponent: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_pow_out<S: Into<Scalar>>(
&self,
result: &Tensor,
exponent: S
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
exponent: S
) -> Fallible<Tensor>
pub fn f_pow_out1(&self, result: &Tensor, exponent: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_pow_out2<S: Into<Scalar>>(
result: &Tensor,
self_scalar: S,
exponent: &Tensor
) -> Fallible<Tensor>
[src]
result: &Tensor,
self_scalar: S,
exponent: &Tensor
) -> Fallible<Tensor>
pub fn f_prelu(&self, weight: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_prelu_backward(
&self,
grad_output: &Tensor,
weight: &Tensor
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
grad_output: &Tensor,
weight: &Tensor
) -> Fallible<(Tensor, Tensor)>
pub fn f_prod(&self) -> Fallible<Tensor>
[src]
pub fn f_prod1(&self, dtype: Kind) -> Fallible<Tensor>
[src]
pub fn f_prod2(&self, dim: i64, keepdim: bool) -> Fallible<Tensor>
[src]
pub fn f_prod3(&self, dim: i64, dtype: Kind) -> Fallible<Tensor>
[src]
pub fn f_prod4(&self, dim: i64, keepdim: bool, dtype: Kind) -> Fallible<Tensor>
[src]
pub fn f_prod_out(
&self,
result: &Tensor,
dim: i64,
keepdim: bool
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
dim: i64,
keepdim: bool
) -> Fallible<Tensor>
pub fn f_prod_out1(
&self,
result: &Tensor,
dim: i64,
dtype: Kind
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
dim: i64,
dtype: Kind
) -> Fallible<Tensor>
pub fn f_prod_out2(
&self,
result: &Tensor,
dim: i64,
keepdim: bool,
dtype: Kind
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
dim: i64,
keepdim: bool,
dtype: Kind
) -> Fallible<Tensor>
pub fn f_pstrf(&self, upper: bool) -> Fallible<(Tensor, Tensor)>
[src]
pub fn f_pstrf_out(
&self,
u: &Tensor,
piv: &Tensor,
upper: bool
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
u: &Tensor,
piv: &Tensor,
upper: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_put_(
&self,
index: &Tensor,
source: &Tensor,
accumulate: bool
) -> Fallible<Tensor>
[src]
&self,
index: &Tensor,
source: &Tensor,
accumulate: bool
) -> Fallible<Tensor>
pub fn f_qr(&self) -> Fallible<(Tensor, Tensor)>
[src]
pub fn f_qr_out(&self, q: &Tensor, r: &Tensor) -> Fallible<(Tensor, Tensor)>
[src]
pub fn f_rand(size: &[i64], options: (Kind, Device)) -> Fallible<Tensor>
[src]
pub fn f_rand_like(&self) -> Fallible<Tensor>
[src]
pub fn f_rand_like1(&self, options: (Kind, Device)) -> Fallible<Tensor>
[src]
pub fn f_rand_out(result: &Tensor, size: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_randint(
high: i64,
size: &[i64],
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
high: i64,
size: &[i64],
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_randint1(
low: i64,
high: i64,
size: &[i64],
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
low: i64,
high: i64,
size: &[i64],
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_randint_like(&self, high: i64) -> Fallible<Tensor>
[src]
pub fn f_randint_like1(&self, low: i64, high: i64) -> Fallible<Tensor>
[src]
pub fn f_randint_like2(
&self,
high: i64,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
&self,
high: i64,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_randint_like3(
&self,
low: i64,
high: i64,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
&self,
low: i64,
high: i64,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_randint_out(
result: &Tensor,
high: i64,
size: &[i64]
) -> Fallible<Tensor>
[src]
result: &Tensor,
high: i64,
size: &[i64]
) -> Fallible<Tensor>
pub fn f_randint_out1(
result: &Tensor,
low: i64,
high: i64,
size: &[i64]
) -> Fallible<Tensor>
[src]
result: &Tensor,
low: i64,
high: i64,
size: &[i64]
) -> Fallible<Tensor>
pub fn f_randn(size: &[i64], options: (Kind, Device)) -> Fallible<Tensor>
[src]
pub fn f_randn_like(&self) -> Fallible<Tensor>
[src]
pub fn f_randn_like1(&self, options: (Kind, Device)) -> Fallible<Tensor>
[src]
pub fn f_randn_out(result: &Tensor, size: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_random_(&self) -> Fallible<Tensor>
[src]
pub fn f_random_1(&self, to_: i64) -> Fallible<Tensor>
[src]
pub fn f_random_2(&self, from: i64, to_: i64) -> Fallible<Tensor>
[src]
pub fn f_randperm(n: i64, options: (Kind, Device)) -> Fallible<Tensor>
[src]
pub fn f_randperm_out(result: &Tensor, n: i64) -> Fallible<Tensor>
[src]
pub fn f_range<S: Into<Scalar>>(
start: S,
end_: S,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
start: S,
end_: S,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_range1<S: Into<Scalar>>(
start: S,
end_: S,
step: S,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
start: S,
end_: S,
step: S,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_range_out<S: Into<Scalar>>(
result: &Tensor,
start: S,
end_: S
) -> Fallible<Tensor>
[src]
result: &Tensor,
start: S,
end_: S
) -> Fallible<Tensor>
pub fn f_range_out1<S: Into<Scalar>>(
result: &Tensor,
start: S,
end_: S,
step: S
) -> Fallible<Tensor>
[src]
result: &Tensor,
start: S,
end_: S,
step: S
) -> Fallible<Tensor>
pub fn f_reciprocal(&self) -> Fallible<Tensor>
[src]
pub fn f_reciprocal_(&self) -> Fallible<Tensor>
[src]
pub fn f_reciprocal_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_reflection_pad1d(&self, padding: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_reflection_pad1d_backward(
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
pub fn f_reflection_pad1d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
pub fn f_reflection_pad1d_out(
&self,
output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
pub fn f_reflection_pad2d(&self, padding: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_reflection_pad2d_backward(
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
pub fn f_reflection_pad2d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
pub fn f_reflection_pad2d_out(
&self,
output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
pub fn f_relu(&self) -> Fallible<Tensor>
[src]
pub fn f_relu_(&self) -> Fallible<Tensor>
[src]
pub fn f_remainder<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_remainder1(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_remainder_<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_remainder_1(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_remainder_out<S: Into<Scalar>>(
&self,
result: &Tensor,
other: S
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
other: S
) -> Fallible<Tensor>
pub fn f_remainder_out1(
&self,
result: &Tensor,
other: &Tensor
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
other: &Tensor
) -> Fallible<Tensor>
pub fn f_renorm<S: Into<Scalar>>(
&self,
p: S,
dim: i64,
maxnorm: S
) -> Fallible<Tensor>
[src]
&self,
p: S,
dim: i64,
maxnorm: S
) -> Fallible<Tensor>
pub fn f_renorm_<S: Into<Scalar>>(
&self,
p: S,
dim: i64,
maxnorm: S
) -> Fallible<Tensor>
[src]
&self,
p: S,
dim: i64,
maxnorm: S
) -> Fallible<Tensor>
pub fn f_renorm_out<S: Into<Scalar>>(
&self,
result: &Tensor,
p: S,
dim: i64,
maxnorm: S
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
p: S,
dim: i64,
maxnorm: S
) -> Fallible<Tensor>
pub fn f_repeat(&self, repeats: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_replication_pad1d(&self, padding: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_replication_pad1d_backward(
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
pub fn f_replication_pad1d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
pub fn f_replication_pad1d_out(
&self,
output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
pub fn f_replication_pad2d(&self, padding: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_replication_pad2d_backward(
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
pub fn f_replication_pad2d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
pub fn f_replication_pad2d_out(
&self,
output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
pub fn f_replication_pad3d(&self, padding: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_replication_pad3d_backward(
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
pub fn f_replication_pad3d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
pub fn f_replication_pad3d_out(
&self,
output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
padding: &[i64]
) -> Fallible<Tensor>
pub fn f_reshape(&self, shape: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_reshape_as(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_resize_(&self, size: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_resize_as_(&self, the_template: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_rfft(
&self,
signal_ndim: i64,
normalized: bool,
onesided: bool
) -> Fallible<Tensor>
[src]
&self,
signal_ndim: i64,
normalized: bool,
onesided: bool
) -> Fallible<Tensor>
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
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
hx: &Tensor,
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool,
batch_first: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_rnn_relu1<T: Borrow<Tensor>>(
data: &Tensor,
batch_sizes: &Tensor,
hx: &Tensor,
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool
) -> Fallible<(Tensor, Tensor)>
[src]
data: &Tensor,
batch_sizes: &Tensor,
hx: &Tensor,
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool
) -> Fallible<(Tensor, Tensor)>
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>
) -> Fallible<Tensor>
[src]
&self,
hx: &Tensor,
w_ih: &Tensor,
w_hh: &Tensor,
b_ih: Option<T>,
b_hh: Option<T>
) -> Fallible<Tensor>
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
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
hx: &Tensor,
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool,
batch_first: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_rnn_tanh1<T: Borrow<Tensor>>(
data: &Tensor,
batch_sizes: &Tensor,
hx: &Tensor,
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool
) -> Fallible<(Tensor, Tensor)>
[src]
data: &Tensor,
batch_sizes: &Tensor,
hx: &Tensor,
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool
) -> Fallible<(Tensor, Tensor)>
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>
) -> Fallible<Tensor>
[src]
&self,
hx: &Tensor,
w_ih: &Tensor,
w_hh: &Tensor,
b_ih: Option<T>,
b_hh: Option<T>
) -> Fallible<Tensor>
pub fn f_roipooling2d_backward(
&self,
rois: &Tensor,
pooledheight: i64,
pooledwidth: i64,
spatialscale: f64,
gradoutput: &Tensor,
argmaxes: &Tensor
) -> Fallible<Tensor>
[src]
&self,
rois: &Tensor,
pooledheight: i64,
pooledwidth: i64,
spatialscale: f64,
gradoutput: &Tensor,
argmaxes: &Tensor
) -> Fallible<Tensor>
pub fn f_roll(&self, shifts: &[i64], dims: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_rot90(&self, k: i64, dims: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_round(&self) -> Fallible<Tensor>
[src]
pub fn f_round_(&self) -> Fallible<Tensor>
[src]
pub fn f_round_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_rrelu(&self, training: bool) -> Fallible<Tensor>
[src]
pub fn f_rrelu_(&self, training: bool) -> Fallible<Tensor>
[src]
pub fn f_rrelu_with_noise(
&self,
noise: &Tensor,
training: bool
) -> Fallible<Tensor>
[src]
&self,
noise: &Tensor,
training: bool
) -> Fallible<Tensor>
pub fn f_rrelu_with_noise_(
&self,
noise: &Tensor,
training: bool
) -> Fallible<Tensor>
[src]
&self,
noise: &Tensor,
training: bool
) -> Fallible<Tensor>
pub fn f_rrelu_with_noise_out(
&self,
output: &Tensor,
noise: &Tensor,
training: bool
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
noise: &Tensor,
training: bool
) -> Fallible<Tensor>
pub fn f_rsqrt(&self) -> Fallible<Tensor>
[src]
pub fn f_rsqrt_(&self) -> Fallible<Tensor>
[src]
pub fn f_rsqrt_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_rsub(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_rsub1<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_s_native_addmm(&self, mat1: &Tensor, mat2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_s_native_addmm_(
&self,
mat1: &Tensor,
mat2: &Tensor
) -> Fallible<Tensor>
[src]
&self,
mat1: &Tensor,
mat2: &Tensor
) -> Fallible<Tensor>
pub fn f_s_native_addmm_out(
&self,
result: &Tensor,
mat1: &Tensor,
mat2: &Tensor
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
mat1: &Tensor,
mat2: &Tensor
) -> Fallible<Tensor>
pub fn f_scatter_(
&self,
dim: i64,
index: &Tensor,
src: &Tensor
) -> Fallible<Tensor>
[src]
&self,
dim: i64,
index: &Tensor,
src: &Tensor
) -> Fallible<Tensor>
pub fn f_scatter_1<S: Into<Scalar>>(
&self,
dim: i64,
index: &Tensor,
value: S
) -> Fallible<Tensor>
[src]
&self,
dim: i64,
index: &Tensor,
value: S
) -> Fallible<Tensor>
pub fn f_scatter_add_(
&self,
dim: i64,
index: &Tensor,
src: &Tensor
) -> Fallible<Tensor>
[src]
&self,
dim: i64,
index: &Tensor,
src: &Tensor
) -> Fallible<Tensor>
pub fn f_select(&self, dim: i64, index: i64) -> Fallible<Tensor>
[src]
pub fn f_selu(&self) -> Fallible<Tensor>
[src]
pub fn f_selu_(&self) -> Fallible<Tensor>
[src]
pub fn f_set_(&self) -> Fallible<Tensor>
[src]
pub fn f_set_1(&self, source: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_set_requires_grad(&self, r: bool) -> Fallible<Tensor>
[src]
pub fn f_sigmoid(&self) -> Fallible<Tensor>
[src]
pub fn f_sigmoid_(&self) -> Fallible<Tensor>
[src]
pub fn f_sigmoid_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_sign(&self) -> Fallible<Tensor>
[src]
pub fn f_sign_(&self) -> Fallible<Tensor>
[src]
pub fn f_sign_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_sin(&self) -> Fallible<Tensor>
[src]
pub fn f_sin_(&self) -> Fallible<Tensor>
[src]
pub fn f_sin_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_sinh(&self) -> Fallible<Tensor>
[src]
pub fn f_sinh_(&self) -> Fallible<Tensor>
[src]
pub fn f_sinh_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_slice(
&self,
dim: i64,
start: i64,
end_: i64,
step: i64
) -> Fallible<Tensor>
[src]
&self,
dim: i64,
start: i64,
end_: i64,
step: i64
) -> Fallible<Tensor>
pub fn f_slogdet(&self) -> Fallible<(Tensor, Tensor)>
[src]
pub fn f_smm(&self, mat2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_smooth_l1_loss(
&self,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
pub fn f_smooth_l1_loss_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
pub fn f_smooth_l1_loss_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
pub fn f_smooth_l1_loss_out(
&self,
output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
pub fn f_soft_margin_loss(
&self,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
pub fn f_soft_margin_loss_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
pub fn f_soft_margin_loss_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
pub fn f_soft_margin_loss_out(
&self,
output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
target: &Tensor,
reduction: i64
) -> Fallible<Tensor>
pub fn f_softmax(&self, dim: i64) -> Fallible<Tensor>
[src]
pub fn f_softmax1(&self, dim: i64, dtype: Kind) -> Fallible<Tensor>
[src]
pub fn f_softplus(&self) -> Fallible<Tensor>
[src]
pub fn f_softplus_out(&self, output: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_softshrink(&self) -> Fallible<Tensor>
[src]
pub fn f_softshrink_out(&self, output: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_sort(&self, dim: i64, descending: bool) -> Fallible<(Tensor, Tensor)>
[src]
pub fn f_sort_out(
&self,
values: &Tensor,
indices: &Tensor,
dim: i64,
descending: bool
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
values: &Tensor,
indices: &Tensor,
dim: i64,
descending: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_sparse_coo_tensor(
size: &[i64],
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
size: &[i64],
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_sparse_coo_tensor1(
indices: &Tensor,
values: &Tensor,
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
indices: &Tensor,
values: &Tensor,
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_sparse_coo_tensor2(
indices: &Tensor,
values: &Tensor,
size: &[i64],
options: (Kind, Device)
) -> Fallible<Tensor>
[src]
indices: &Tensor,
values: &Tensor,
size: &[i64],
options: (Kind, Device)
) -> Fallible<Tensor>
pub fn f_sparse_resize_(
&self,
size: &[i64],
sparse_dim: i64,
dense_dim: i64
) -> Fallible<Tensor>
[src]
&self,
size: &[i64],
sparse_dim: i64,
dense_dim: i64
) -> Fallible<Tensor>
pub fn f_sparse_resize_and_clear_(
&self,
size: &[i64],
sparse_dim: i64,
dense_dim: i64
) -> Fallible<Tensor>
[src]
&self,
size: &[i64],
sparse_dim: i64,
dense_dim: i64
) -> Fallible<Tensor>
pub fn f_sqrt(&self) -> Fallible<Tensor>
[src]
pub fn f_sqrt_(&self) -> Fallible<Tensor>
[src]
pub fn f_sqrt_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_squeeze(&self) -> Fallible<Tensor>
[src]
pub fn f_squeeze1(&self, dim: i64) -> Fallible<Tensor>
[src]
pub fn f_squeeze_(&self) -> Fallible<Tensor>
[src]
pub fn f_squeeze_1(&self, dim: i64) -> Fallible<Tensor>
[src]
pub fn f_sspaddmm(&self, mat1: &Tensor, mat2: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_sspaddmm_out(
&self,
result: &Tensor,
mat1: &Tensor,
mat2: &Tensor
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
mat1: &Tensor,
mat2: &Tensor
) -> Fallible<Tensor>
pub fn f_stack<T: Borrow<Tensor>>(tensors: &[T], dim: i64) -> Fallible<Tensor>
[src]
pub fn f_stack_out<T: Borrow<Tensor>>(
result: &Tensor,
tensors: &[T],
dim: i64
) -> Fallible<Tensor>
[src]
result: &Tensor,
tensors: &[T],
dim: i64
) -> Fallible<Tensor>
pub fn f_std(&self, unbiased: bool) -> Fallible<Tensor>
[src]
pub fn f_std1(
&self,
dim: i64,
unbiased: bool,
keepdim: bool
) -> Fallible<Tensor>
[src]
&self,
dim: i64,
unbiased: bool,
keepdim: bool
) -> Fallible<Tensor>
pub fn f_std_out(
&self,
result: &Tensor,
dim: i64,
unbiased: bool,
keepdim: bool
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
dim: i64,
unbiased: bool,
keepdim: bool
) -> Fallible<Tensor>
pub fn f_stft<T: Borrow<Tensor>>(
&self,
n_fft: i64,
hop_length: i64,
win_length: i64,
window: Option<T>,
normalized: bool,
onesided: bool
) -> Fallible<Tensor>
[src]
&self,
n_fft: i64,
hop_length: i64,
win_length: i64,
window: Option<T>,
normalized: bool,
onesided: bool
) -> Fallible<Tensor>
pub fn f_sub(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_sub1<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_sub_(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_sub_1<S: Into<Scalar>>(&self, other: S) -> Fallible<Tensor>
[src]
pub fn f_sub_out(&self, result: &Tensor, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_sum(&self) -> Fallible<Tensor>
[src]
pub fn f_sum1(&self, dtype: Kind) -> Fallible<Tensor>
[src]
pub fn f_sum2(&self, dim: &[i64], keepdim: bool) -> Fallible<Tensor>
[src]
pub fn f_sum3(&self, dim: &[i64], dtype: Kind) -> Fallible<Tensor>
[src]
pub fn f_sum4(
&self,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Fallible<Tensor>
[src]
&self,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Fallible<Tensor>
pub fn f_sum_out(
&self,
result: &Tensor,
dim: &[i64],
keepdim: bool
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
dim: &[i64],
keepdim: bool
) -> Fallible<Tensor>
pub fn f_sum_out1(
&self,
result: &Tensor,
dim: &[i64],
dtype: Kind
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
dim: &[i64],
dtype: Kind
) -> Fallible<Tensor>
pub fn f_sum_out2(
&self,
result: &Tensor,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Fallible<Tensor>
pub fn f_svd(
&self,
some: bool,
compute_uv: bool
) -> Fallible<(Tensor, Tensor, Tensor)>
[src]
&self,
some: bool,
compute_uv: bool
) -> Fallible<(Tensor, Tensor, Tensor)>
pub fn f_svd_out(
&self,
u: &Tensor,
s: &Tensor,
v: &Tensor,
some: bool,
compute_uv: bool
) -> Fallible<(Tensor, Tensor, Tensor)>
[src]
&self,
u: &Tensor,
s: &Tensor,
v: &Tensor,
some: bool,
compute_uv: bool
) -> Fallible<(Tensor, Tensor, Tensor)>
pub fn f_symeig(
&self,
eigenvectors: bool,
upper: bool
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
eigenvectors: bool,
upper: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_symeig_out(
&self,
e: &Tensor,
v: &Tensor,
eigenvectors: bool,
upper: bool
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
e: &Tensor,
v: &Tensor,
eigenvectors: bool,
upper: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_tr(&self) -> Fallible<Tensor>
[src]
pub fn f_t_(&self) -> Fallible<Tensor>
[src]
pub fn f_take(&self, index: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_take_out(&self, result: &Tensor, index: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_tan(&self) -> Fallible<Tensor>
[src]
pub fn f_tan_(&self) -> Fallible<Tensor>
[src]
pub fn f_tan_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_tanh(&self) -> Fallible<Tensor>
[src]
pub fn f_tanh_(&self) -> Fallible<Tensor>
[src]
pub fn f_tanh_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_tensordot(
&self,
other: &Tensor,
dims_self: &[i64],
dims_other: &[i64]
) -> Fallible<Tensor>
[src]
&self,
other: &Tensor,
dims_self: &[i64],
dims_other: &[i64]
) -> Fallible<Tensor>
pub fn f_threshold<S: Into<Scalar>>(
&self,
threshold: S,
value: S
) -> Fallible<Tensor>
[src]
&self,
threshold: S,
value: S
) -> Fallible<Tensor>
pub fn f_threshold_<S: Into<Scalar>>(
&self,
threshold: S,
value: S
) -> Fallible<Tensor>
[src]
&self,
threshold: S,
value: S
) -> Fallible<Tensor>
pub fn f_threshold_backward<S: Into<Scalar>>(
&self,
grad_output: &Tensor,
threshold: S
) -> Fallible<Tensor>
[src]
&self,
grad_output: &Tensor,
threshold: S
) -> Fallible<Tensor>
pub fn f_threshold_out<S: Into<Scalar>>(
&self,
result: &Tensor,
threshold: S,
value: S
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
threshold: S,
value: S
) -> Fallible<Tensor>
pub fn f_to_(&self, device: Device) -> Fallible<Tensor>
[src]
pub fn f_to1(
&self,
options: (Kind, Device),
non_blocking: bool,
copy: bool
) -> Fallible<Tensor>
[src]
&self,
options: (Kind, Device),
non_blocking: bool,
copy: bool
) -> Fallible<Tensor>
pub fn f_to2(
&self,
dtype: Kind,
non_blocking: bool,
copy: bool
) -> Fallible<Tensor>
[src]
&self,
dtype: Kind,
non_blocking: bool,
copy: bool
) -> Fallible<Tensor>
pub fn f_to3(
&self,
other: &Tensor,
non_blocking: bool,
copy: bool
) -> Fallible<Tensor>
[src]
&self,
other: &Tensor,
non_blocking: bool,
copy: bool
) -> Fallible<Tensor>
pub fn f_to4(
&self,
device: Device,
dtype: Kind,
non_blocking: bool,
copy: bool
) -> Fallible<Tensor>
[src]
&self,
device: Device,
dtype: Kind,
non_blocking: bool,
copy: bool
) -> Fallible<Tensor>
pub fn f_to_dense(&self) -> Fallible<Tensor>
[src]
pub fn f_to_sparse(&self) -> Fallible<Tensor>
[src]
pub fn f_to_sparse1(&self, sparse_dim: i64) -> Fallible<Tensor>
[src]
pub fn f_topk(
&self,
k: i64,
dim: i64,
largest: bool,
sorted: bool
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
k: i64,
dim: i64,
largest: bool,
sorted: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_topk_out(
&self,
values: &Tensor,
indices: &Tensor,
k: i64,
dim: i64,
largest: bool,
sorted: bool
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
values: &Tensor,
indices: &Tensor,
k: i64,
dim: i64,
largest: bool,
sorted: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_totype(&self, scalar_type: Kind) -> Fallible<Tensor>
[src]
pub fn f_trace(&self) -> Fallible<Tensor>
[src]
pub fn f_transpose(&self, dim0: i64, dim1: i64) -> Fallible<Tensor>
[src]
pub fn f_transpose_(&self, dim0: i64, dim1: i64) -> Fallible<Tensor>
[src]
pub fn f_tril(&self, diagonal: i64) -> Fallible<Tensor>
[src]
pub fn f_tril_(&self, diagonal: i64) -> Fallible<Tensor>
[src]
pub fn f_tril_out(&self, result: &Tensor, diagonal: i64) -> Fallible<Tensor>
[src]
pub fn f_triplet_margin_loss(
anchor: &Tensor,
positive: &Tensor,
negative: &Tensor,
margin: f64,
p: f64,
eps: f64,
swap: bool,
reduction: i64
) -> Fallible<Tensor>
[src]
anchor: &Tensor,
positive: &Tensor,
negative: &Tensor,
margin: f64,
p: f64,
eps: f64,
swap: bool,
reduction: i64
) -> Fallible<Tensor>
pub fn f_triu(&self, diagonal: i64) -> Fallible<Tensor>
[src]
pub fn f_triu_(&self, diagonal: i64) -> Fallible<Tensor>
[src]
pub fn f_triu_out(&self, result: &Tensor, diagonal: i64) -> Fallible<Tensor>
[src]
pub fn f_trtrs(
&self,
a: &Tensor,
upper: bool,
transpose: bool,
unitriangular: bool
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
a: &Tensor,
upper: bool,
transpose: bool,
unitriangular: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_trtrs_out(
&self,
x: &Tensor,
m: &Tensor,
a: &Tensor,
upper: bool,
transpose: bool,
unitriangular: bool
) -> Fallible<(Tensor, Tensor)>
[src]
&self,
x: &Tensor,
m: &Tensor,
a: &Tensor,
upper: bool,
transpose: bool,
unitriangular: bool
) -> Fallible<(Tensor, Tensor)>
pub fn f_trunc(&self) -> Fallible<Tensor>
[src]
pub fn f_trunc_(&self) -> Fallible<Tensor>
[src]
pub fn f_trunc_out(&self, result: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_type_as(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_unfold(&self, dimension: i64, size: i64, step: i64) -> Fallible<Tensor>
[src]
pub fn f_uniform_(&self, from: f64, to_: f64) -> Fallible<Tensor>
[src]
pub fn f_unsqueeze(&self, dim: i64) -> Fallible<Tensor>
[src]
pub fn f_unsqueeze_(&self, dim: i64) -> Fallible<Tensor>
[src]
pub fn f_upsample_bilinear2d(
&self,
output_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
[src]
&self,
output_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
pub fn f_upsample_bilinear2d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
[src]
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
pub fn f_upsample_bilinear2d_backward_out(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
[src]
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
pub fn f_upsample_bilinear2d_out(
&self,
output: &Tensor,
output_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
output_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
pub fn f_upsample_linear1d(
&self,
output_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
[src]
&self,
output_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
pub fn f_upsample_linear1d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
[src]
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
pub fn f_upsample_linear1d_backward_out(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
[src]
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
pub fn f_upsample_linear1d_out(
&self,
output: &Tensor,
output_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
output_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
pub fn f_upsample_nearest1d(&self, output_size: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_upsample_nearest1d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Fallible<Tensor>
[src]
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Fallible<Tensor>
pub fn f_upsample_nearest1d_backward_out(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Fallible<Tensor>
[src]
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Fallible<Tensor>
pub fn f_upsample_nearest1d_out(
&self,
output: &Tensor,
output_size: &[i64]
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
output_size: &[i64]
) -> Fallible<Tensor>
pub fn f_upsample_nearest2d(&self, output_size: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_upsample_nearest2d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Fallible<Tensor>
[src]
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Fallible<Tensor>
pub fn f_upsample_nearest2d_backward_out(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Fallible<Tensor>
[src]
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Fallible<Tensor>
pub fn f_upsample_nearest2d_out(
&self,
output: &Tensor,
output_size: &[i64]
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
output_size: &[i64]
) -> Fallible<Tensor>
pub fn f_upsample_nearest3d(&self, output_size: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_upsample_nearest3d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Fallible<Tensor>
[src]
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Fallible<Tensor>
pub fn f_upsample_nearest3d_backward_out(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Fallible<Tensor>
[src]
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Fallible<Tensor>
pub fn f_upsample_nearest3d_out(
&self,
output: &Tensor,
output_size: &[i64]
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
output_size: &[i64]
) -> Fallible<Tensor>
pub fn f_upsample_trilinear3d(
&self,
output_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
[src]
&self,
output_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
pub fn f_upsample_trilinear3d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
[src]
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
pub fn f_upsample_trilinear3d_backward_out(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
[src]
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
pub fn f_upsample_trilinear3d_out(
&self,
output: &Tensor,
output_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
[src]
&self,
output: &Tensor,
output_size: &[i64],
align_corners: bool
) -> Fallible<Tensor>
pub fn f_values(&self) -> Fallible<Tensor>
[src]
pub fn f_var(&self, unbiased: bool) -> Fallible<Tensor>
[src]
pub fn f_var1(
&self,
dim: i64,
unbiased: bool,
keepdim: bool
) -> Fallible<Tensor>
[src]
&self,
dim: i64,
unbiased: bool,
keepdim: bool
) -> Fallible<Tensor>
pub fn f_var_out(
&self,
result: &Tensor,
dim: i64,
unbiased: bool,
keepdim: bool
) -> Fallible<Tensor>
[src]
&self,
result: &Tensor,
dim: i64,
unbiased: bool,
keepdim: bool
) -> Fallible<Tensor>
pub fn f_view(&self, size: &[i64]) -> Fallible<Tensor>
[src]
pub fn f_view_as(&self, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_where_(&self, condition: &Tensor, other: &Tensor) -> Fallible<Tensor>
[src]
pub fn f_zero_(&self) -> Fallible<Tensor>
[src]
pub fn f_zeros(size: &[i64], options: (Kind, Device)) -> Fallible<Tensor>
[src]
pub fn f_zeros_like(&self) -> Fallible<Tensor>
[src]
pub fn f_zeros_like1(&self, options: (Kind, Device)) -> Fallible<Tensor>
[src]
pub fn f_zeros_out(result: &Tensor, size: &[i64]) -> Fallible<Tensor>
[src]
impl Tensor
[src]
pub fn abs(&self) -> Tensor
[src]
pub fn abs_(&self) -> Tensor
[src]
pub fn abs_out(&self, result: &Tensor) -> Tensor
[src]
pub fn acos(&self) -> Tensor
[src]
pub fn acos_(&self) -> Tensor
[src]
pub fn acos_out(&self, result: &Tensor) -> Tensor
[src]
pub fn adaptive_avg_pool1d(&self, output_size: &[i64]) -> Tensor
[src]
pub fn adaptive_avg_pool2d(&self, output_size: &[i64]) -> Tensor
[src]
pub fn adaptive_avg_pool2d_backward(&self, grad_output: &Tensor) -> Tensor
[src]
pub fn adaptive_avg_pool2d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor
) -> Tensor
pub fn adaptive_avg_pool2d_out(
&self,
output: &Tensor,
output_size: &[i64]
) -> Tensor
[src]
&self,
output: &Tensor,
output_size: &[i64]
) -> Tensor
pub fn adaptive_avg_pool3d(&self, output_size: &[i64]) -> Tensor
[src]
pub fn adaptive_avg_pool3d_backward(&self, grad_output: &Tensor) -> Tensor
[src]
pub fn adaptive_avg_pool3d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor
) -> Tensor
pub fn adaptive_avg_pool3d_out(
&self,
output: &Tensor,
output_size: &[i64]
) -> Tensor
[src]
&self,
output: &Tensor,
output_size: &[i64]
) -> Tensor
pub fn adaptive_max_pool1d(&self, output_size: &[i64]) -> (Tensor, Tensor)
[src]
pub fn adaptive_max_pool2d(&self, output_size: &[i64]) -> (Tensor, Tensor)
[src]
pub fn adaptive_max_pool2d_backward(
&self,
grad_output: &Tensor,
indices: &Tensor
) -> Tensor
[src]
&self,
grad_output: &Tensor,
indices: &Tensor
) -> Tensor
pub fn adaptive_max_pool2d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor
) -> Tensor
pub fn adaptive_max_pool2d_out(
&self,
output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> (Tensor, Tensor)
[src]
&self,
output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> (Tensor, Tensor)
pub fn adaptive_max_pool3d(&self, output_size: &[i64]) -> (Tensor, Tensor)
[src]
pub fn adaptive_max_pool3d_backward(
&self,
grad_output: &Tensor,
indices: &Tensor
) -> Tensor
[src]
&self,
grad_output: &Tensor,
indices: &Tensor
) -> Tensor
pub fn adaptive_max_pool3d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor
) -> Tensor
pub fn adaptive_max_pool3d_out(
&self,
output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> (Tensor, Tensor)
[src]
&self,
output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> (Tensor, Tensor)
pub fn g_add(&self, other: &Tensor) -> Tensor
[src]
pub fn g_add1<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn g_add_(&self, other: &Tensor) -> Tensor
[src]
pub fn g_add_1<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn add_out(&self, result: &Tensor, other: &Tensor) -> Tensor
[src]
pub fn addbmm(&self, batch1: &Tensor, batch2: &Tensor) -> Tensor
[src]
pub fn addbmm_(&self, batch1: &Tensor, batch2: &Tensor) -> Tensor
[src]
pub fn addbmm_out(
&self,
result: &Tensor,
batch1: &Tensor,
batch2: &Tensor
) -> Tensor
[src]
&self,
result: &Tensor,
batch1: &Tensor,
batch2: &Tensor
) -> Tensor
pub fn addcdiv(&self, tensor1: &Tensor, tensor2: &Tensor) -> Tensor
[src]
pub fn addcdiv_(&self, tensor1: &Tensor, tensor2: &Tensor) -> Tensor
[src]
pub fn addcdiv_out(
&self,
result: &Tensor,
tensor1: &Tensor,
tensor2: &Tensor
) -> Tensor
[src]
&self,
result: &Tensor,
tensor1: &Tensor,
tensor2: &Tensor
) -> Tensor
pub fn addcmul(&self, tensor1: &Tensor, tensor2: &Tensor) -> Tensor
[src]
pub fn addcmul_(&self, tensor1: &Tensor, tensor2: &Tensor) -> Tensor
[src]
pub fn addcmul_out(
&self,
result: &Tensor,
tensor1: &Tensor,
tensor2: &Tensor
) -> Tensor
[src]
&self,
result: &Tensor,
tensor1: &Tensor,
tensor2: &Tensor
) -> Tensor
pub fn addmm(&self, mat1: &Tensor, mat2: &Tensor) -> Tensor
[src]
pub fn addmm_(&self, mat1: &Tensor, mat2: &Tensor) -> Tensor
[src]
pub fn addmm_out(&self, result: &Tensor, mat1: &Tensor, mat2: &Tensor) -> Tensor
[src]
pub fn addmv(&self, mat: &Tensor, vec: &Tensor) -> Tensor
[src]
pub fn addmv_(&self, mat: &Tensor, vec: &Tensor) -> Tensor
[src]
pub fn addmv_out(&self, result: &Tensor, mat: &Tensor, vec: &Tensor) -> Tensor
[src]
pub fn addr(&self, vec1: &Tensor, vec2: &Tensor) -> Tensor
[src]
pub fn addr_(&self, vec1: &Tensor, vec2: &Tensor) -> Tensor
[src]
pub fn addr_out(&self, result: &Tensor, vec1: &Tensor, vec2: &Tensor) -> Tensor
[src]
pub fn alias(&self) -> Tensor
[src]
pub fn all(&self) -> Tensor
[src]
pub fn all1(&self, dim: i64, keepdim: bool) -> Tensor
[src]
pub fn all_out(&self, result: &Tensor, dim: i64, keepdim: bool) -> Tensor
[src]
pub fn alpha_dropout(&self, p: f64, train: bool) -> Tensor
[src]
pub fn alpha_dropout_(&self, p: f64, train: bool) -> Tensor
[src]
pub fn any(&self) -> Tensor
[src]
pub fn any1(&self, dim: i64, keepdim: bool) -> Tensor
[src]
pub fn any_out(&self, result: &Tensor, dim: i64, keepdim: bool) -> Tensor
[src]
pub fn arange<S: Into<Scalar>>(end_: S, options: (Kind, Device)) -> Tensor
[src]
pub fn arange1<S: Into<Scalar>>(
start: S,
end_: S,
options: (Kind, Device)
) -> Tensor
[src]
start: S,
end_: S,
options: (Kind, Device)
) -> Tensor
pub fn arange2<S: Into<Scalar>>(
start: S,
end_: S,
step: S,
options: (Kind, Device)
) -> Tensor
[src]
start: S,
end_: S,
step: S,
options: (Kind, Device)
) -> Tensor
pub fn arange_out<S: Into<Scalar>>(result: &Tensor, end_: S) -> Tensor
[src]
pub fn arange_out1<S: Into<Scalar>>(
result: &Tensor,
start: S,
end_: S
) -> Tensor
[src]
result: &Tensor,
start: S,
end_: S
) -> Tensor
pub fn arange_out2<S: Into<Scalar>>(
result: &Tensor,
start: S,
end_: S,
step: S
) -> Tensor
[src]
result: &Tensor,
start: S,
end_: S,
step: S
) -> Tensor
pub fn argmax(&self) -> Tensor
[src]
pub fn argmax1(&self, dim: i64, keepdim: bool) -> Tensor
[src]
pub fn argmin(&self) -> Tensor
[src]
pub fn argmin1(&self, dim: i64, keepdim: bool) -> Tensor
[src]
pub fn as_strided(&self, size: &[i64], stride: &[i64]) -> Tensor
[src]
pub fn as_strided1(
&self,
size: &[i64],
stride: &[i64],
storage_offset: i64
) -> Tensor
[src]
&self,
size: &[i64],
stride: &[i64],
storage_offset: i64
) -> Tensor
pub fn as_strided_(&self, size: &[i64], stride: &[i64]) -> Tensor
[src]
pub fn as_strided_1(
&self,
size: &[i64],
stride: &[i64],
storage_offset: i64
) -> Tensor
[src]
&self,
size: &[i64],
stride: &[i64],
storage_offset: i64
) -> Tensor
pub fn asin(&self) -> Tensor
[src]
pub fn asin_(&self) -> Tensor
[src]
pub fn asin_out(&self, result: &Tensor) -> Tensor
[src]
pub fn atan(&self) -> Tensor
[src]
pub fn atan2(&self, other: &Tensor) -> Tensor
[src]
pub fn atan2_(&self, other: &Tensor) -> Tensor
[src]
pub fn atan2_out(&self, result: &Tensor, other: &Tensor) -> Tensor
[src]
pub fn atan_(&self) -> Tensor
[src]
pub fn atan_out(&self, result: &Tensor) -> Tensor
[src]
pub fn avg_pool1d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Tensor
[src]
&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
) -> Tensor
[src]
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Tensor
pub fn avg_pool2d_backward(
&self,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Tensor
[src]
&self,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Tensor
pub fn avg_pool2d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Tensor
pub fn avg_pool2d_out(
&self,
output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Tensor
[src]
&self,
output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Tensor
pub fn avg_pool3d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Tensor
[src]
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Tensor
pub fn avg_pool3d_backward(
&self,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Tensor
[src]
&self,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Tensor
pub fn avg_pool3d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Tensor
pub fn avg_pool3d_out(
&self,
output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Tensor
[src]
&self,
output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
ceil_mode: bool,
count_include_pad: bool
) -> Tensor
pub fn baddbmm(&self, batch1: &Tensor, batch2: &Tensor) -> Tensor
[src]
pub fn baddbmm_(&self, batch1: &Tensor, batch2: &Tensor) -> Tensor
[src]
pub fn baddbmm_out(
&self,
result: &Tensor,
batch1: &Tensor,
batch2: &Tensor
) -> Tensor
[src]
&self,
result: &Tensor,
batch1: &Tensor,
batch2: &Tensor
) -> Tensor
pub fn bartlett_window(window_length: i64, options: (Kind, Device)) -> Tensor
[src]
pub fn bartlett_window1(
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Tensor
[src]
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
[src]
&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 bernoulli(&self) -> Tensor
[src]
pub fn bernoulli1(&self, p: f64) -> Tensor
[src]
pub fn bernoulli_(&self, p: &Tensor) -> Tensor
[src]
pub fn bernoulli_1(&self, p: f64) -> Tensor
[src]
pub fn bernoulli_out(&self, result: &Tensor) -> Tensor
[src]
pub fn bilinear<T: Borrow<Tensor>>(
input1: &Tensor,
input2: &Tensor,
weight: &Tensor,
bias: Option<T>
) -> Tensor
[src]
input1: &Tensor,
input2: &Tensor,
weight: &Tensor,
bias: Option<T>
) -> Tensor
pub fn binary_cross_entropy(
&self,
target: &Tensor,
weight: &Tensor,
reduction: i64
) -> Tensor
[src]
&self,
target: &Tensor,
weight: &Tensor,
reduction: i64
) -> Tensor
pub fn binary_cross_entropy_backward<T: Borrow<Tensor>>(
&self,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64
) -> Tensor
[src]
&self,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64
) -> Tensor
pub fn binary_cross_entropy_backward_out<T: Borrow<Tensor>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64
) -> Tensor
pub fn binary_cross_entropy_out(
&self,
output: &Tensor,
target: &Tensor,
weight: &Tensor,
reduction: i64
) -> Tensor
[src]
&self,
output: &Tensor,
target: &Tensor,
weight: &Tensor,
reduction: i64
) -> Tensor
pub fn binary_cross_entropy_with_logits<T: Borrow<Tensor>>(
&self,
target: &Tensor,
weight: Option<T>,
pos_weight: Option<T>,
reduction: i64
) -> Tensor
[src]
&self,
target: &Tensor,
weight: Option<T>,
pos_weight: Option<T>,
reduction: i64
) -> 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: i64
) -> Tensor
[src]
&self,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
pos_weight: Option<T>,
reduction: i64
) -> Tensor
pub fn bincount<T: Borrow<Tensor>>(
&self,
weights: Option<T>,
minlength: i64
) -> Tensor
[src]
&self,
weights: Option<T>,
minlength: i64
) -> Tensor
pub fn blackman_window(window_length: i64, options: (Kind, Device)) -> Tensor
[src]
pub fn blackman_window1(
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Tensor
[src]
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Tensor
pub fn bmm(&self, mat2: &Tensor) -> Tensor
[src]
pub fn bmm_out(&self, result: &Tensor, mat2: &Tensor) -> Tensor
[src]
pub fn btrifact(&self, pivot: bool) -> (Tensor, Tensor)
[src]
pub fn btrifact_out(
&self,
a_lu: &Tensor,
pivots: &Tensor,
pivot: bool
) -> (Tensor, Tensor)
[src]
&self,
a_lu: &Tensor,
pivots: &Tensor,
pivot: bool
) -> (Tensor, Tensor)
pub fn btrifact_with_info(&self, pivot: bool) -> (Tensor, Tensor, Tensor)
[src]
pub fn btrifact_with_info_out(
&self,
a_lu: &Tensor,
pivots: &Tensor,
info: &Tensor,
pivot: bool
) -> (Tensor, Tensor, Tensor)
[src]
&self,
a_lu: &Tensor,
pivots: &Tensor,
info: &Tensor,
pivot: bool
) -> (Tensor, Tensor, Tensor)
pub fn btrisolve(&self, lu_data: &Tensor, lu_pivots: &Tensor) -> Tensor
[src]
pub fn btrisolve_out(
&self,
result: &Tensor,
lu_data: &Tensor,
lu_pivots: &Tensor
) -> Tensor
[src]
&self,
result: &Tensor,
lu_data: &Tensor,
lu_pivots: &Tensor
) -> Tensor
pub fn cat<T: Borrow<Tensor>>(tensors: &[T], dim: i64) -> Tensor
[src]
pub fn cat_out<T: Borrow<Tensor>>(
result: &Tensor,
tensors: &[T],
dim: i64
) -> Tensor
[src]
result: &Tensor,
tensors: &[T],
dim: i64
) -> Tensor
pub fn cauchy_(&self, median: f64, sigma: f64) -> Tensor
[src]
pub fn ceil(&self) -> Tensor
[src]
pub fn ceil_(&self) -> Tensor
[src]
pub fn ceil_out(&self, result: &Tensor) -> Tensor
[src]
pub fn celu(&self) -> Tensor
[src]
pub fn celu_(&self) -> Tensor
[src]
pub fn chain_matmul<T: Borrow<Tensor>>(matrices: &[T]) -> Tensor
[src]
pub fn cholesky(&self, upper: bool) -> Tensor
[src]
pub fn cholesky_out(&self, result: &Tensor, upper: bool) -> Tensor
[src]
pub fn clamp<S: Into<Scalar>>(&self, min: S, max: S) -> Tensor
[src]
pub fn clamp_<S: Into<Scalar>>(&self, min: S, max: S) -> Tensor
[src]
pub fn clamp_max<S: Into<Scalar>>(&self, max: S) -> Tensor
[src]
pub fn clamp_max_<S: Into<Scalar>>(&self, max: S) -> Tensor
[src]
pub fn clamp_max_out<S: Into<Scalar>>(&self, result: &Tensor, max: S) -> Tensor
[src]
pub fn clamp_min<S: Into<Scalar>>(&self, min: S) -> Tensor
[src]
pub fn clamp_min_<S: Into<Scalar>>(&self, min: S) -> Tensor
[src]
pub fn clamp_min_out<S: Into<Scalar>>(&self, result: &Tensor, min: S) -> Tensor
[src]
pub fn clamp_out<S: Into<Scalar>>(
&self,
result: &Tensor,
min: S,
max: S
) -> Tensor
[src]
&self,
result: &Tensor,
min: S,
max: S
) -> Tensor
pub fn coalesce(&self) -> Tensor
[src]
pub fn constant_pad_nd(&self, pad: &[i64]) -> Tensor
[src]
pub fn contiguous(&self) -> Tensor
[src]
pub fn conv1d(
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
groups: i64
) -> Tensor
[src]
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
groups: i64
) -> Tensor
pub fn conv2d(
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
groups: i64
) -> Tensor
[src]
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
groups: i64
) -> Tensor
pub fn conv3d(
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
groups: i64
) -> Tensor
[src]
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
dilation: &[i64],
groups: i64
) -> Tensor
pub fn conv_tbc(&self, weight: &Tensor, bias: &Tensor, pad: i64) -> Tensor
[src]
pub fn conv_tbc_backward(
&self,
input: &Tensor,
weight: &Tensor,
bias: &Tensor,
pad: i64
) -> (Tensor, Tensor, Tensor)
[src]
&self,
input: &Tensor,
weight: &Tensor,
bias: &Tensor,
pad: i64
) -> (Tensor, Tensor, Tensor)
pub fn conv_transpose1d(
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
groups: i64,
dilation: &[i64]
) -> Tensor
[src]
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
groups: i64,
dilation: &[i64]
) -> Tensor
pub fn conv_transpose2d(
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
groups: i64,
dilation: &[i64]
) -> Tensor
[src]
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
groups: i64,
dilation: &[i64]
) -> Tensor
pub fn conv_transpose3d(
&self,
weight: &Tensor,
bias: &Tensor,
stride: &[i64],
padding: &[i64],
output_padding: &[i64],
groups: i64,
dilation: &[i64]
) -> Tensor
[src]
&self,
weight: &Tensor,
bias: &Tensor,
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
[src]
&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_(&self, src: &Tensor, non_blocking: bool) -> Tensor
[src]
pub fn cos(&self) -> Tensor
[src]
pub fn cos_(&self) -> Tensor
[src]
pub fn cos_out(&self, result: &Tensor) -> Tensor
[src]
pub fn cosh(&self) -> Tensor
[src]
pub fn cosh_(&self) -> Tensor
[src]
pub fn cosh_out(&self, result: &Tensor) -> Tensor
[src]
pub fn cosine_embedding_loss(
input1: &Tensor,
input2: &Tensor,
target: &Tensor,
margin: f64,
reduction: i64
) -> Tensor
[src]
input1: &Tensor,
input2: &Tensor,
target: &Tensor,
margin: f64,
reduction: i64
) -> Tensor
pub fn cross(&self, other: &Tensor, dim: i64) -> Tensor
[src]
pub fn cross_out(&self, result: &Tensor, other: &Tensor, dim: i64) -> Tensor
[src]
pub fn ctc_loss(
log_probs: &Tensor,
targets: &Tensor,
input_lengths: &[i64],
target_lengths: &[i64],
blank: i64,
reduction: i64
) -> Tensor
[src]
log_probs: &Tensor,
targets: &Tensor,
input_lengths: &[i64],
target_lengths: &[i64],
blank: i64,
reduction: i64
) -> Tensor
pub fn ctc_loss1(
log_probs: &Tensor,
targets: &Tensor,
input_lengths: &Tensor,
target_lengths: &Tensor,
blank: i64,
reduction: i64
) -> Tensor
[src]
log_probs: &Tensor,
targets: &Tensor,
input_lengths: &Tensor,
target_lengths: &Tensor,
blank: i64,
reduction: i64
) -> Tensor
pub fn cudnn_affine_grid_generator(
theta: &Tensor,
n: i64,
c: i64,
h: i64,
w: i64
) -> Tensor
[src]
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
[src]
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)
[src]
&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 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
) -> (Tensor, Tensor, Tensor)
[src]
&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 cudnn_convolution<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Tensor
[src]
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Tensor
pub fn cudnn_convolution_backward_bias(grad_output: &Tensor) -> Tensor
[src]
pub fn cudnn_convolution_backward_input(
self_size: &[i64],
grad_output: &Tensor,
weight: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Tensor
[src]
self_size: &[i64],
grad_output: &Tensor,
weight: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Tensor
pub fn cudnn_convolution_backward_weight(
&self,
weight_size: &[i64],
grad_output: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Tensor
[src]
&self,
weight_size: &[i64],
grad_output: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Tensor
pub fn cudnn_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
[src]
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
output_padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Tensor
pub fn cudnn_convolution_transpose_backward_bias(grad_output: &Tensor) -> Tensor
[src]
pub fn cudnn_convolution_transpose_backward_input(
grad_output: &Tensor,
weight: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Tensor
[src]
grad_output: &Tensor,
weight: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Tensor
pub fn cudnn_convolution_transpose_backward_weight(
&self,
weight_size: &[i64],
grad_output: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Tensor
[src]
&self,
weight_size: &[i64],
grad_output: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Tensor
pub fn cudnn_grid_sampler(&self, grid: &Tensor) -> Tensor
[src]
pub fn cudnn_grid_sampler_backward(
&self,
grid: &Tensor,
grad_output: &Tensor
) -> (Tensor, Tensor)
[src]
&self,
grid: &Tensor,
grad_output: &Tensor
) -> (Tensor, Tensor)
pub fn cumprod(&self, dim: i64) -> Tensor
[src]
pub fn cumprod1(&self, dim: i64, dtype: Kind) -> Tensor
[src]
pub fn cumprod_out(&self, result: &Tensor, dim: i64) -> Tensor
[src]
pub fn cumprod_out1(&self, result: &Tensor, dim: i64, dtype: Kind) -> Tensor
[src]
pub fn cumsum(&self, dim: i64) -> Tensor
[src]
pub fn cumsum1(&self, dim: i64, dtype: Kind) -> Tensor
[src]
pub fn cumsum_out(&self, result: &Tensor, dim: i64) -> Tensor
[src]
pub fn cumsum_out1(&self, result: &Tensor, dim: i64, dtype: Kind) -> Tensor
[src]
pub fn det(&self) -> Tensor
[src]
pub fn detach(&self) -> Tensor
[src]
pub fn detach_(&self) -> Tensor
[src]
pub fn diag(&self, diagonal: i64) -> Tensor
[src]
pub fn diag_embed(&self, offset: i64, dim1: i64, dim2: i64) -> Tensor
[src]
pub fn diag_out(&self, result: &Tensor, diagonal: i64) -> Tensor
[src]
pub fn diagflat(&self, offset: i64) -> Tensor
[src]
pub fn diagonal(&self, offset: i64, dim1: i64, dim2: i64) -> Tensor
[src]
pub fn digamma(&self) -> Tensor
[src]
pub fn digamma_(&self) -> Tensor
[src]
pub fn digamma_out(&self, result: &Tensor) -> Tensor
[src]
pub fn dist(&self, other: &Tensor) -> Tensor
[src]
pub fn g_div(&self, other: &Tensor) -> Tensor
[src]
pub fn g_div1<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn g_div_(&self, other: &Tensor) -> Tensor
[src]
pub fn g_div_1<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn div_out(&self, result: &Tensor, other: &Tensor) -> Tensor
[src]
pub fn dot(&self, tensor: &Tensor) -> Tensor
[src]
pub fn dot_out(&self, result: &Tensor, tensor: &Tensor) -> Tensor
[src]
pub fn dropout(&self, p: f64, train: bool) -> Tensor
[src]
pub fn dropout_(&self, p: f64, train: bool) -> Tensor
[src]
pub fn eig(&self, eigenvectors: bool) -> (Tensor, Tensor)
[src]
pub fn eig_out(
&self,
e: &Tensor,
v: &Tensor,
eigenvectors: bool
) -> (Tensor, Tensor)
[src]
&self,
e: &Tensor,
v: &Tensor,
eigenvectors: bool
) -> (Tensor, Tensor)
pub fn elu(&self) -> Tensor
[src]
pub fn elu_(&self) -> Tensor
[src]
pub fn elu_out(&self, output: &Tensor) -> Tensor
[src]
pub fn embedding(
weight: &Tensor,
indices: &Tensor,
padding_idx: i64,
scale_grad_by_freq: bool,
sparse: bool
) -> Tensor
[src]
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
[src]
grad: &Tensor,
indices: &Tensor,
num_weights: i64,
padding_idx: i64,
scale_grad_by_freq: bool,
sparse: bool
) -> Tensor
pub fn embedding_bag(
weight: &Tensor,
indices: &Tensor,
offsets: &Tensor,
scale_grad_by_freq: bool,
mode: i64,
sparse: bool
) -> (Tensor, Tensor, Tensor, Tensor)
[src]
weight: &Tensor,
indices: &Tensor,
offsets: &Tensor,
scale_grad_by_freq: bool,
mode: i64,
sparse: bool
) -> (Tensor, Tensor, Tensor, Tensor)
pub fn embedding_dense_backward(
grad: &Tensor,
indices: &Tensor,
num_weights: i64,
padding_idx: i64,
scale_grad_by_freq: bool
) -> Tensor
[src]
grad: &Tensor,
indices: &Tensor,
num_weights: i64,
padding_idx: i64,
scale_grad_by_freq: bool
) -> Tensor
pub fn embedding_renorm_(
&self,
indices: &Tensor,
max_norm: f64,
norm_type: f64
) -> Tensor
[src]
&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
[src]
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
[src]
pub fn empty_like(&self) -> Tensor
[src]
pub fn empty_like1(&self, options: (Kind, Device)) -> Tensor
[src]
pub fn empty_out(result: &Tensor, size: &[i64]) -> Tensor
[src]
pub fn empty_strided(
size: &[i64],
stride: &[i64],
options: (Kind, Device)
) -> Tensor
[src]
size: &[i64],
stride: &[i64],
options: (Kind, Device)
) -> Tensor
pub fn eq<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn eq1(&self, other: &Tensor) -> Tensor
[src]
pub fn eq_<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn eq_1(&self, other: &Tensor) -> Tensor
[src]
pub fn eq_out<S: Into<Scalar>>(&self, result: &Tensor, other: S) -> Tensor
[src]
pub fn eq_out1(&self, result: &Tensor, other: &Tensor) -> Tensor
[src]
pub fn erf(&self) -> Tensor
[src]
pub fn erf_(&self) -> Tensor
[src]
pub fn erf_out(&self, result: &Tensor) -> Tensor
[src]
pub fn erfc(&self) -> Tensor
[src]
pub fn erfc_(&self) -> Tensor
[src]
pub fn erfc_out(&self, result: &Tensor) -> Tensor
[src]
pub fn erfinv(&self) -> Tensor
[src]
pub fn erfinv_(&self) -> Tensor
[src]
pub fn erfinv_out(&self, result: &Tensor) -> Tensor
[src]
pub fn exp(&self) -> Tensor
[src]
pub fn exp_(&self) -> Tensor
[src]
pub fn exp_out(&self, result: &Tensor) -> Tensor
[src]
pub fn expand(&self, size: &[i64], implicit: bool) -> Tensor
[src]
pub fn expand_as(&self, other: &Tensor) -> Tensor
[src]
pub fn expm1(&self) -> Tensor
[src]
pub fn expm1_(&self) -> Tensor
[src]
pub fn expm1_out(&self, result: &Tensor) -> Tensor
[src]
pub fn exponential_(&self, lambd: f64) -> Tensor
[src]
pub fn eye(n: i64, options: (Kind, Device)) -> Tensor
[src]
pub fn eye1(n: i64, m: i64, options: (Kind, Device)) -> Tensor
[src]
pub fn eye_out(result: &Tensor, n: i64) -> Tensor
[src]
pub fn eye_out1(result: &Tensor, n: i64, m: i64) -> Tensor
[src]
pub fn feature_alpha_dropout(&self, p: f64, train: bool) -> Tensor
[src]
pub fn feature_alpha_dropout_(&self, p: f64, train: bool) -> Tensor
[src]
pub fn feature_dropout(&self, p: f64, train: bool) -> Tensor
[src]
pub fn feature_dropout_(&self, p: f64, train: bool) -> Tensor
[src]
pub fn fft(&self, signal_ndim: i64, normalized: bool) -> Tensor
[src]
pub fn fill_<S: Into<Scalar>>(&self, value: S) -> Tensor
[src]
pub fn fill_1(&self, value: &Tensor) -> Tensor
[src]
pub fn flatten(&self, start_dim: i64, end_dim: i64) -> Tensor
[src]
pub fn flip(&self, dims: &[i64]) -> Tensor
[src]
pub fn floor(&self) -> Tensor
[src]
pub fn floor_(&self) -> Tensor
[src]
pub fn floor_out(&self, result: &Tensor) -> Tensor
[src]
pub fn fmod<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn fmod1(&self, other: &Tensor) -> Tensor
[src]
pub fn fmod_<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn fmod_1(&self, other: &Tensor) -> Tensor
[src]
pub fn fmod_out<S: Into<Scalar>>(&self, result: &Tensor, other: S) -> Tensor
[src]
pub fn fmod_out1(&self, result: &Tensor, other: &Tensor) -> Tensor
[src]
pub fn frac(&self) -> Tensor
[src]
pub fn frac_(&self) -> Tensor
[src]
pub fn frac_out(&self, result: &Tensor) -> Tensor
[src]
pub fn fractional_max_pool2d(
&self,
kernel_size: &[i64],
output_size: &[i64],
random_samples: &Tensor
) -> (Tensor, Tensor)
[src]
&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
[src]
&self,
grad_output: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
indices: &Tensor
) -> Tensor
pub fn fractional_max_pool2d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
indices: &Tensor
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
indices: &Tensor
) -> Tensor
pub fn fractional_max_pool2d_out(
&self,
output: &Tensor,
indices: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
random_samples: &Tensor
) -> (Tensor, Tensor)
[src]
&self,
output: &Tensor,
indices: &Tensor,
kernel_size: &[i64],
output_size: &[i64],
random_samples: &Tensor
) -> (Tensor, Tensor)
pub fn frobenius_norm(&self) -> Tensor
[src]
pub fn frobenius_norm1(&self, dim: &[i64], keepdim: bool) -> Tensor
[src]
pub fn frobenius_norm_out(
&self,
result: &Tensor,
dim: &[i64],
keepdim: bool
) -> Tensor
[src]
&self,
result: &Tensor,
dim: &[i64],
keepdim: bool
) -> Tensor
pub fn full<S: Into<Scalar>>(
size: &[i64],
fill_value: S,
options: (Kind, Device)
) -> Tensor
[src]
size: &[i64],
fill_value: S,
options: (Kind, Device)
) -> Tensor
pub fn full_like<S: Into<Scalar>>(&self, fill_value: S) -> Tensor
[src]
pub fn full_like1<S: Into<Scalar>>(
&self,
fill_value: S,
options: (Kind, Device)
) -> Tensor
[src]
&self,
fill_value: S,
options: (Kind, Device)
) -> Tensor
pub fn full_out<S: Into<Scalar>>(
result: &Tensor,
size: &[i64],
fill_value: S
) -> Tensor
[src]
result: &Tensor,
size: &[i64],
fill_value: S
) -> Tensor
pub fn gather(&self, dim: i64, index: &Tensor) -> Tensor
[src]
pub fn gather_out(&self, result: &Tensor, dim: i64, index: &Tensor) -> Tensor
[src]
pub fn ge<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn ge1(&self, other: &Tensor) -> Tensor
[src]
pub fn ge_<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn ge_1(&self, other: &Tensor) -> Tensor
[src]
pub fn ge_out<S: Into<Scalar>>(&self, result: &Tensor, other: S) -> Tensor
[src]
pub fn ge_out1(&self, result: &Tensor, other: &Tensor) -> Tensor
[src]
pub fn gels(&self, a: &Tensor) -> (Tensor, Tensor)
[src]
pub fn gels_out(&self, x: &Tensor, qr: &Tensor, a: &Tensor) -> (Tensor, Tensor)
[src]
pub fn geometric_(&self, p: f64) -> Tensor
[src]
pub fn geqrf(&self) -> (Tensor, Tensor)
[src]
pub fn geqrf_out(&self, result0: &Tensor, result1: &Tensor) -> (Tensor, Tensor)
[src]
pub fn ger(&self, vec2: &Tensor) -> Tensor
[src]
pub fn ger_out(&self, result: &Tensor, vec2: &Tensor) -> Tensor
[src]
pub fn gesv(&self, a: &Tensor) -> (Tensor, Tensor)
[src]
pub fn gesv_out(
&self,
solution: &Tensor,
lu: &Tensor,
a: &Tensor
) -> (Tensor, Tensor)
[src]
&self,
solution: &Tensor,
lu: &Tensor,
a: &Tensor
) -> (Tensor, Tensor)
pub fn glu(&self, dim: i64) -> Tensor
[src]
pub fn glu_backward(&self, grad_output: &Tensor, dim: i64) -> Tensor
[src]
pub fn glu_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
dim: i64
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
dim: i64
) -> Tensor
pub fn glu_out(&self, output: &Tensor, dim: i64) -> Tensor
[src]
pub fn grad(&self) -> Tensor
[src]
pub fn grid_sampler(
&self,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64
) -> Tensor
[src]
&self,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64
) -> Tensor
pub fn grid_sampler_2d(
&self,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64
) -> Tensor
[src]
&self,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64
) -> Tensor
pub fn grid_sampler_2d_backward(
&self,
grad_output: &Tensor,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64
) -> (Tensor, Tensor)
[src]
&self,
grad_output: &Tensor,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64
) -> (Tensor, Tensor)
pub fn grid_sampler_3d(
&self,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64
) -> Tensor
[src]
&self,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64
) -> Tensor
pub fn grid_sampler_3d_backward(
&self,
grad_output: &Tensor,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64
) -> (Tensor, Tensor)
[src]
&self,
grad_output: &Tensor,
grid: &Tensor,
interpolation_mode: i64,
padding_mode: i64
) -> (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
[src]
&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)
[src]
&self,
hx: &Tensor,
params: &[T],
has_biases: bool,
num_layers: i64,
dropout: f64,
train: bool,
bidirectional: bool,
batch_first: bool
) -> (Tensor, Tensor)
pub fn gru1<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)
[src]
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 gru_cell<T: Borrow<Tensor>>(
&self,
hx: &Tensor,
w_ih: &Tensor,
w_hh: &Tensor,
b_ih: Option<T>,
b_hh: Option<T>
) -> Tensor
[src]
&self,
hx: &Tensor,
w_ih: &Tensor,
w_hh: &Tensor,
b_ih: Option<T>,
b_hh: Option<T>
) -> Tensor
pub fn gt<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn gt1(&self, other: &Tensor) -> Tensor
[src]
pub fn gt_<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn gt_1(&self, other: &Tensor) -> Tensor
[src]
pub fn gt_out<S: Into<Scalar>>(&self, result: &Tensor, other: S) -> Tensor
[src]
pub fn gt_out1(&self, result: &Tensor, other: &Tensor) -> Tensor
[src]
pub fn hamming_window(window_length: i64, options: (Kind, Device)) -> Tensor
[src]
pub fn hamming_window1(
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Tensor
[src]
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Tensor
pub fn hamming_window2(
window_length: i64,
periodic: bool,
alpha: f64,
options: (Kind, Device)
) -> Tensor
[src]
window_length: i64,
periodic: bool,
alpha: f64,
options: (Kind, Device)
) -> Tensor
pub fn hamming_window3(
window_length: i64,
periodic: bool,
alpha: f64,
beta: f64,
options: (Kind, Device)
) -> Tensor
[src]
window_length: i64,
periodic: bool,
alpha: f64,
beta: f64,
options: (Kind, Device)
) -> Tensor
pub fn hann_window(window_length: i64, options: (Kind, Device)) -> Tensor
[src]
pub fn hann_window1(
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Tensor
[src]
window_length: i64,
periodic: bool,
options: (Kind, Device)
) -> Tensor
pub fn hardshrink(&self) -> Tensor
[src]
pub fn hardshrink_backward<S: Into<Scalar>>(
&self,
grad_out: &Tensor,
lambd: S
) -> Tensor
[src]
&self,
grad_out: &Tensor,
lambd: S
) -> Tensor
pub fn hardtanh(&self) -> Tensor
[src]
pub fn hardtanh_(&self) -> Tensor
[src]
pub fn hardtanh_out(&self, output: &Tensor) -> Tensor
[src]
pub fn hinge_embedding_loss(
&self,
target: &Tensor,
margin: f64,
reduction: i64
) -> Tensor
[src]
&self,
target: &Tensor,
margin: f64,
reduction: i64
) -> Tensor
pub fn histc(&self, bins: i64) -> Tensor
[src]
pub fn histc_out(&self, result: &Tensor, bins: i64) -> Tensor
[src]
pub fn hspmm(mat1: &Tensor, mat2: &Tensor) -> Tensor
[src]
pub fn hspmm_out(result: &Tensor, mat1: &Tensor, mat2: &Tensor) -> Tensor
[src]
pub fn ifft(&self, signal_ndim: i64, normalized: bool) -> Tensor
[src]
pub fn index<T: Borrow<Tensor>>(&self, indices: &[T]) -> Tensor
[src]
pub fn index_add_(&self, dim: i64, index: &Tensor, source: &Tensor) -> Tensor
[src]
pub fn index_copy_(&self, dim: i64, index: &Tensor, source: &Tensor) -> Tensor
[src]
pub fn index_fill_<S: Into<Scalar>>(
&self,
dim: i64,
index: &Tensor,
value: S
) -> Tensor
[src]
&self,
dim: i64,
index: &Tensor,
value: S
) -> Tensor
pub fn index_fill_1(&self, dim: i64, index: &Tensor, value: &Tensor) -> Tensor
[src]
pub fn index_put<T: Borrow<Tensor>>(
&self,
indices: &[T],
values: &Tensor
) -> Tensor
[src]
&self,
indices: &[T],
values: &Tensor
) -> Tensor
pub fn index_put_<T: Borrow<Tensor>>(
&self,
indices: &[T],
values: &Tensor
) -> Tensor
[src]
&self,
indices: &[T],
values: &Tensor
) -> Tensor
pub fn index_select(&self, dim: i64, index: &Tensor) -> Tensor
[src]
pub fn index_select_out(
&self,
result: &Tensor,
dim: i64,
index: &Tensor
) -> Tensor
[src]
&self,
result: &Tensor,
dim: i64,
index: &Tensor
) -> Tensor
pub fn indices(&self) -> Tensor
[src]
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
[src]
&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 inverse(&self) -> Tensor
[src]
pub fn inverse_out(&self, result: &Tensor) -> Tensor
[src]
pub fn irfft(
&self,
signal_ndim: i64,
normalized: bool,
onesided: bool,
signal_sizes: &[i64]
) -> Tensor
[src]
&self,
signal_ndim: i64,
normalized: bool,
onesided: bool,
signal_sizes: &[i64]
) -> Tensor
pub fn isclose(
&self,
other: &Tensor,
rtol: f64,
atol: f64,
equal_nan: bool
) -> Tensor
[src]
&self,
other: &Tensor,
rtol: f64,
atol: f64,
equal_nan: bool
) -> Tensor
pub fn kl_div(&self, target: &Tensor, reduction: i64) -> Tensor
[src]
pub fn kl_div_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
[src]
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
pub fn kthvalue(&self, k: i64, dim: i64, keepdim: bool) -> (Tensor, Tensor)
[src]
pub fn kthvalue_out(
&self,
values: &Tensor,
indices: &Tensor,
k: i64,
dim: i64,
keepdim: bool
) -> (Tensor, Tensor)
[src]
&self,
values: &Tensor,
indices: &Tensor,
k: i64,
dim: i64,
keepdim: bool
) -> (Tensor, Tensor)
pub fn l1_loss(&self, target: &Tensor, reduction: i64) -> Tensor
[src]
pub fn l1_loss_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
[src]
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
pub fn l1_loss_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
pub fn l1_loss_out(
&self,
output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
[src]
&self,
output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
pub fn layer_norm<T: Borrow<Tensor>>(
&self,
normalized_shape: &[i64],
weight: Option<T>,
bias: Option<T>,
eps: f64,
cudnn_enable: bool
) -> Tensor
[src]
&self,
normalized_shape: &[i64],
weight: Option<T>,
bias: Option<T>,
eps: f64,
cudnn_enable: bool
) -> Tensor
pub fn le<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn le1(&self, other: &Tensor) -> Tensor
[src]
pub fn le_<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn le_1(&self, other: &Tensor) -> Tensor
[src]
pub fn le_out<S: Into<Scalar>>(&self, result: &Tensor, other: S) -> Tensor
[src]
pub fn le_out1(&self, result: &Tensor, other: &Tensor) -> Tensor
[src]
pub fn leaky_relu(&self) -> Tensor
[src]
pub fn leaky_relu_(&self) -> Tensor
[src]
pub fn leaky_relu_out(&self, output: &Tensor) -> Tensor
[src]
pub fn lerp<S: Into<Scalar>>(&self, end_: &Tensor, weight: S) -> Tensor
[src]
pub fn lerp_<S: Into<Scalar>>(&self, end_: &Tensor, weight: S) -> Tensor
[src]
pub fn lerp_out<S: Into<Scalar>>(
&self,
result: &Tensor,
end_: &Tensor,
weight: S
) -> Tensor
[src]
&self,
result: &Tensor,
end_: &Tensor,
weight: S
) -> Tensor
pub fn lgamma(&self) -> Tensor
[src]
pub fn lgamma_(&self) -> Tensor
[src]
pub fn lgamma_out(&self, result: &Tensor) -> Tensor
[src]
pub fn linear(&self, weight: &Tensor, bias: &Tensor) -> Tensor
[src]
pub fn linspace<S: Into<Scalar>>(
start: S,
end_: S,
options: (Kind, Device)
) -> Tensor
[src]
start: S,
end_: S,
options: (Kind, Device)
) -> Tensor
pub fn linspace1<S: Into<Scalar>>(
start: S,
end_: S,
steps: i64,
options: (Kind, Device)
) -> Tensor
[src]
start: S,
end_: S,
steps: i64,
options: (Kind, Device)
) -> Tensor
pub fn linspace_out<S: Into<Scalar>>(
result: &Tensor,
start: S,
end_: S
) -> Tensor
[src]
result: &Tensor,
start: S,
end_: S
) -> Tensor
pub fn linspace_out1<S: Into<Scalar>>(
result: &Tensor,
start: S,
end_: S,
steps: i64
) -> Tensor
[src]
result: &Tensor,
start: S,
end_: S,
steps: i64
) -> Tensor
pub fn log(&self) -> Tensor
[src]
pub fn log10(&self) -> Tensor
[src]
pub fn log10_(&self) -> Tensor
[src]
pub fn log10_out(&self, result: &Tensor) -> Tensor
[src]
pub fn log1p(&self) -> Tensor
[src]
pub fn log1p_(&self) -> Tensor
[src]
pub fn log1p_out(&self, result: &Tensor) -> Tensor
[src]
pub fn log2(&self) -> Tensor
[src]
pub fn log2_(&self) -> Tensor
[src]
pub fn log2_out(&self, result: &Tensor) -> Tensor
[src]
pub fn log_(&self) -> Tensor
[src]
pub fn log_normal_(&self, mean: f64, std: f64) -> Tensor
[src]
pub fn log_out(&self, result: &Tensor) -> Tensor
[src]
pub fn log_sigmoid(&self) -> Tensor
[src]
pub fn log_sigmoid_backward(
&self,
grad_output: &Tensor,
buffer: &Tensor
) -> Tensor
[src]
&self,
grad_output: &Tensor,
buffer: &Tensor
) -> Tensor
pub fn log_sigmoid_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
buffer: &Tensor
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
buffer: &Tensor
) -> Tensor
pub fn log_sigmoid_out(&self, output: &Tensor) -> Tensor
[src]
pub fn log_softmax(&self, dim: i64) -> Tensor
[src]
pub fn log_softmax1(&self, dim: i64, dtype: Kind) -> Tensor
[src]
pub fn logdet(&self) -> Tensor
[src]
pub fn logspace<S: Into<Scalar>>(
start: S,
end_: S,
options: (Kind, Device)
) -> Tensor
[src]
start: S,
end_: S,
options: (Kind, Device)
) -> Tensor
pub fn logspace1<S: Into<Scalar>>(
start: S,
end_: S,
steps: i64,
options: (Kind, Device)
) -> Tensor
[src]
start: S,
end_: S,
steps: i64,
options: (Kind, Device)
) -> Tensor
pub fn logspace_out<S: Into<Scalar>>(
result: &Tensor,
start: S,
end_: S
) -> Tensor
[src]
result: &Tensor,
start: S,
end_: S
) -> Tensor
pub fn logspace_out1<S: Into<Scalar>>(
result: &Tensor,
start: S,
end_: S,
steps: i64
) -> Tensor
[src]
result: &Tensor,
start: S,
end_: S,
steps: i64
) -> Tensor
pub fn logsumexp(&self, dim: i64, keepdim: bool) -> Tensor
[src]
pub fn logsumexp_out(&self, result: &Tensor, dim: i64, keepdim: bool) -> Tensor
[src]
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)
[src]
&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 lstm1<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)
[src]
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 lstm_cell<T: Borrow<Tensor>>(
&self,
hx: &[T],
w_ih: &Tensor,
w_hh: &Tensor,
b_ih: Option<T>,
b_hh: Option<T>
) -> (Tensor, Tensor)
[src]
&self,
hx: &[T],
w_ih: &Tensor,
w_hh: &Tensor,
b_ih: Option<T>,
b_hh: Option<T>
) -> (Tensor, Tensor)
pub fn lt<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn lt1(&self, other: &Tensor) -> Tensor
[src]
pub fn lt_<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn lt_1(&self, other: &Tensor) -> Tensor
[src]
pub fn lt_out<S: Into<Scalar>>(&self, result: &Tensor, other: S) -> Tensor
[src]
pub fn lt_out1(&self, result: &Tensor, other: &Tensor) -> Tensor
[src]
pub fn margin_ranking_loss(
input1: &Tensor,
input2: &Tensor,
target: &Tensor,
margin: f64,
reduction: i64
) -> Tensor
[src]
input1: &Tensor,
input2: &Tensor,
target: &Tensor,
margin: f64,
reduction: i64
) -> Tensor
pub fn masked_fill_<S: Into<Scalar>>(&self, mask: &Tensor, value: S) -> Tensor
[src]
pub fn masked_fill_1(&self, mask: &Tensor, value: &Tensor) -> Tensor
[src]
pub fn masked_scatter_(&self, mask: &Tensor, source: &Tensor) -> Tensor
[src]
pub fn masked_select(&self, mask: &Tensor) -> Tensor
[src]
pub fn masked_select_out(&self, result: &Tensor, mask: &Tensor) -> Tensor
[src]
pub fn matmul(&self, other: &Tensor) -> Tensor
[src]
pub fn matmul_out(&self, result: &Tensor, other: &Tensor) -> Tensor
[src]
pub fn matrix_power(&self, n: i64) -> Tensor
[src]
pub fn matrix_rank(&self, symmetric: bool) -> Tensor
[src]
pub fn matrix_rank1(&self, tol: f64, symmetric: bool) -> Tensor
[src]
pub fn max(&self) -> Tensor
[src]
pub fn max1(&self, other: &Tensor) -> Tensor
[src]
pub fn max2(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)
[src]
pub fn max_out(&self, result: &Tensor, other: &Tensor) -> Tensor
[src]
pub fn max_out1(
&self,
max: &Tensor,
max_values: &Tensor,
dim: i64,
keepdim: bool
) -> (Tensor, Tensor)
[src]
&self,
max: &Tensor,
max_values: &Tensor,
dim: i64,
keepdim: bool
) -> (Tensor, Tensor)
pub fn max_pool1d(
&self,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> Tensor
[src]
&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)
[src]
&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
[src]
&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)
[src]
&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
[src]
&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_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool,
indices: &Tensor
) -> Tensor
[src]
&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,
output: &Tensor,
indices: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> (Tensor, Tensor)
[src]
&self,
output: &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
[src]
&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)
[src]
&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
[src]
&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_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool,
indices: &Tensor
) -> Tensor
[src]
&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,
output: &Tensor,
indices: &Tensor,
kernel_size: &[i64],
stride: &[i64],
padding: &[i64],
dilation: &[i64],
ceil_mode: bool
) -> (Tensor, Tensor)
[src]
&self,
output: &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
[src]
pub fn max_unpool2d_backward(
&self,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Tensor
[src]
&self,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Tensor
pub fn max_unpool2d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Tensor
pub fn max_unpool2d_out(
&self,
output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Tensor
[src]
&self,
output: &Tensor,
indices: &Tensor,
output_size: &[i64]
) -> Tensor
pub fn max_unpool3d(
&self,
indices: &Tensor,
output_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Tensor
[src]
&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
[src]
&self,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Tensor
pub fn max_unpool3d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
indices: &Tensor,
output_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Tensor
pub fn max_unpool3d_out(
&self,
output: &Tensor,
indices: &Tensor,
output_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Tensor
[src]
&self,
output: &Tensor,
indices: &Tensor,
output_size: &[i64],
stride: &[i64],
padding: &[i64]
) -> Tensor
pub fn max_values(&self, dim: i64, keepdim: bool) -> Tensor
[src]
pub fn mean(&self) -> Tensor
[src]
pub fn mean1(&self, dtype: Kind) -> Tensor
[src]
pub fn mean2(&self, dim: i64, keepdim: bool) -> Tensor
[src]
pub fn mean3(&self, dim: i64, dtype: Kind) -> Tensor
[src]
pub fn mean4(&self, dim: i64, keepdim: bool, dtype: Kind) -> Tensor
[src]
pub fn mean_out(&self, result: &Tensor, dim: i64, keepdim: bool) -> Tensor
[src]
pub fn mean_out1(&self, result: &Tensor, dim: i64, dtype: Kind) -> Tensor
[src]
pub fn mean_out2(
&self,
result: &Tensor,
dim: i64,
keepdim: bool,
dtype: Kind
) -> Tensor
[src]
&self,
result: &Tensor,
dim: i64,
keepdim: bool,
dtype: Kind
) -> Tensor
pub fn median(&self) -> Tensor
[src]
pub fn median1(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)
[src]
pub fn median_out(
&self,
values: &Tensor,
indices: &Tensor,
dim: i64,
keepdim: bool
) -> (Tensor, Tensor)
[src]
&self,
values: &Tensor,
indices: &Tensor,
dim: i64,
keepdim: bool
) -> (Tensor, Tensor)
pub fn min(&self) -> Tensor
[src]
pub fn min1(&self, other: &Tensor) -> Tensor
[src]
pub fn min2(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)
[src]
pub fn min_out(&self, result: &Tensor, other: &Tensor) -> Tensor
[src]
pub fn min_out1(
&self,
min: &Tensor,
min_indices: &Tensor,
dim: i64,
keepdim: bool
) -> (Tensor, Tensor)
[src]
&self,
min: &Tensor,
min_indices: &Tensor,
dim: i64,
keepdim: bool
) -> (Tensor, Tensor)
pub fn min_values(&self, dim: i64, keepdim: bool) -> Tensor
[src]
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)
[src]
&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)
[src]
&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
[src]
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Tensor
pub fn miopen_convolution_backward_bias(grad_output: &Tensor) -> Tensor
[src]
pub fn miopen_convolution_backward_input(
self_size: &[i64],
grad_output: &Tensor,
weight: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Tensor
[src]
self_size: &[i64],
grad_output: &Tensor,
weight: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Tensor
pub fn miopen_convolution_backward_weight(
&self,
weight_size: &[i64],
grad_output: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Tensor
[src]
&self,
weight_size: &[i64],
grad_output: &Tensor,
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
[src]
&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_convolution_transpose_backward_input(
grad_output: &Tensor,
weight: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Tensor
[src]
grad_output: &Tensor,
weight: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Tensor
pub fn miopen_convolution_transpose_backward_weight(
&self,
weight_size: &[i64],
grad_output: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Tensor
[src]
&self,
weight_size: &[i64],
grad_output: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
benchmark: bool,
deterministic: bool
) -> Tensor
pub fn mkldnn_convolution<T: Borrow<Tensor>>(
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64
) -> Tensor
[src]
&self,
weight: &Tensor,
bias: Option<T>,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64
) -> Tensor
pub fn mkldnn_convolution_backward_input(
self_size: &[i64],
grad_output: &Tensor,
weight: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
bias_defined: bool
) -> Tensor
[src]
self_size: &[i64],
grad_output: &Tensor,
weight: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
bias_defined: bool
) -> Tensor
pub fn mkldnn_convolution_backward_weights(
&self,
weight_size: &[i64],
grad_output: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
bias_defined: bool
) -> (Tensor, Tensor)
[src]
&self,
weight_size: &[i64],
grad_output: &Tensor,
padding: &[i64],
stride: &[i64],
dilation: &[i64],
groups: i64,
bias_defined: bool
) -> (Tensor, Tensor)
pub fn mm(&self, mat2: &Tensor) -> Tensor
[src]
pub fn mm_out(&self, result: &Tensor, mat2: &Tensor) -> Tensor
[src]
pub fn mode(&self, dim: i64, keepdim: bool) -> (Tensor, Tensor)
[src]
pub fn mode_out(
&self,
values: &Tensor,
indices: &Tensor,
dim: i64,
keepdim: bool
) -> (Tensor, Tensor)
[src]
&self,
values: &Tensor,
indices: &Tensor,
dim: i64,
keepdim: bool
) -> (Tensor, Tensor)
pub fn mse_loss(&self, target: &Tensor, reduction: i64) -> Tensor
[src]
pub fn mse_loss_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
[src]
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
pub fn mse_loss_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
pub fn mse_loss_out(
&self,
output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
[src]
&self,
output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
pub fn g_mul(&self, other: &Tensor) -> Tensor
[src]
pub fn g_mul1<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn g_mul_(&self, other: &Tensor) -> Tensor
[src]
pub fn g_mul_1<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn mul_out(&self, result: &Tensor, other: &Tensor) -> Tensor
[src]
pub fn multilabel_margin_loss(&self, target: &Tensor, reduction: i64) -> Tensor
[src]
pub fn multilabel_margin_loss_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64,
is_target: &Tensor
) -> Tensor
[src]
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64,
is_target: &Tensor
) -> Tensor
pub fn multilabel_margin_loss_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: i64,
is_target: &Tensor
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: i64,
is_target: &Tensor
) -> Tensor
pub fn multilabel_margin_loss_out(
&self,
output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
[src]
&self,
output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
pub fn multinomial(&self, num_samples: i64, replacement: bool) -> Tensor
[src]
pub fn multinomial_out(
&self,
result: &Tensor,
num_samples: i64,
replacement: bool
) -> Tensor
[src]
&self,
result: &Tensor,
num_samples: i64,
replacement: bool
) -> Tensor
pub fn mv(&self, vec: &Tensor) -> Tensor
[src]
pub fn mv_out(&self, result: &Tensor, vec: &Tensor) -> Tensor
[src]
pub fn mvlgamma(&self, p: i64) -> Tensor
[src]
pub fn mvlgamma_(&self, p: i64) -> Tensor
[src]
pub fn narrow(&self, dim: i64, start: i64, length: i64) -> Tensor
[src]
pub fn narrow_copy(&self, dim: i64, start: i64, length: i64) -> Tensor
[src]
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)
[src]
&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_clone(&self) -> Tensor
[src]
pub fn native_norm(&self) -> Tensor
[src]
pub fn native_pow<S: Into<Scalar>>(&self, exponent: S) -> Tensor
[src]
pub fn native_pow_out<S: Into<Scalar>>(
&self,
result: &Tensor,
exponent: S
) -> Tensor
[src]
&self,
result: &Tensor,
exponent: S
) -> Tensor
pub fn native_resize_as_(&self, the_template: &Tensor) -> Tensor
[src]
pub fn native_zero_(&self) -> Tensor
[src]
pub fn ne<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn ne1(&self, other: &Tensor) -> Tensor
[src]
pub fn ne_<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn ne_1(&self, other: &Tensor) -> Tensor
[src]
pub fn ne_out<S: Into<Scalar>>(&self, result: &Tensor, other: S) -> Tensor
[src]
pub fn ne_out1(&self, result: &Tensor, other: &Tensor) -> Tensor
[src]
pub fn neg(&self) -> Tensor
[src]
pub fn neg_(&self) -> Tensor
[src]
pub fn neg_out(&self, result: &Tensor) -> Tensor
[src]
pub fn g_nll_loss(
&self,
target: &Tensor,
weight: &Tensor,
reduction: i64,
ignore_index: i64
) -> Tensor
[src]
&self,
target: &Tensor,
weight: &Tensor,
reduction: i64,
ignore_index: i64
) -> Tensor
pub fn nll_loss2d(
&self,
target: &Tensor,
weight: &Tensor,
reduction: i64,
ignore_index: i64
) -> Tensor
[src]
&self,
target: &Tensor,
weight: &Tensor,
reduction: i64,
ignore_index: i64
) -> Tensor
pub fn nll_loss2d_backward<T: Borrow<Tensor>>(
&self,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64,
ignore_index: i64,
total_weight: &Tensor
) -> Tensor
[src]
&self,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64,
ignore_index: i64,
total_weight: &Tensor
) -> Tensor
pub fn nll_loss2d_backward_out<T: Borrow<Tensor>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64,
ignore_index: i64,
total_weight: &Tensor
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64,
ignore_index: i64,
total_weight: &Tensor
) -> Tensor
pub fn nll_loss2d_out(
&self,
output: &Tensor,
target: &Tensor,
weight: &Tensor,
reduction: i64,
ignore_index: i64
) -> Tensor
[src]
&self,
output: &Tensor,
target: &Tensor,
weight: &Tensor,
reduction: i64,
ignore_index: i64
) -> Tensor
pub fn nll_loss_backward<T: Borrow<Tensor>>(
&self,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64,
ignore_index: i64,
total_weight: &Tensor
) -> Tensor
[src]
&self,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64,
ignore_index: i64,
total_weight: &Tensor
) -> Tensor
pub fn nll_loss_backward_out<T: Borrow<Tensor>>(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64,
ignore_index: i64,
total_weight: &Tensor
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
weight: Option<T>,
reduction: i64,
ignore_index: i64,
total_weight: &Tensor
) -> Tensor
pub fn nll_loss_out(
&self,
output: &Tensor,
target: &Tensor,
weight: &Tensor,
reduction: i64,
ignore_index: i64
) -> Tensor
[src]
&self,
output: &Tensor,
target: &Tensor,
weight: &Tensor,
reduction: i64,
ignore_index: i64
) -> Tensor
pub fn nonzero(&self) -> Tensor
[src]
pub fn nonzero_out(&self, result: &Tensor) -> Tensor
[src]
pub fn norm(&self) -> Tensor
[src]
pub fn norm1<S: Into<Scalar>>(&self, p: S, dim: i64, keepdim: bool) -> Tensor
[src]
pub fn norm_except_dim(v: &Tensor, pow: i64, dim: i64) -> Tensor
[src]
pub fn norm_out<S: Into<Scalar>>(
&self,
result: &Tensor,
p: S,
dim: i64,
keepdim: bool
) -> Tensor
[src]
&self,
result: &Tensor,
p: S,
dim: i64,
keepdim: bool
) -> Tensor
pub fn normal(mean: &Tensor, std: f64) -> Tensor
[src]
pub fn normal1(mean: f64, std: &Tensor) -> Tensor
[src]
pub fn normal2(mean: &Tensor, std: &Tensor) -> Tensor
[src]
pub fn normal_(&self, mean: f64, std: f64) -> Tensor
[src]
pub fn normal_out(output: &Tensor, mean: &Tensor, std: f64) -> Tensor
[src]
pub fn normal_out1(output: &Tensor, mean: f64, std: &Tensor) -> Tensor
[src]
pub fn normal_out2(output: &Tensor, mean: &Tensor, std: &Tensor) -> Tensor
[src]
pub fn nuclear_norm(&self, keepdim: bool) -> Tensor
[src]
pub fn nuclear_norm_out(&self, result: &Tensor, keepdim: bool) -> Tensor
[src]
pub fn ones(size: &[i64], options: (Kind, Device)) -> Tensor
[src]
pub fn ones_like(&self) -> Tensor
[src]
pub fn ones_like1(&self, options: (Kind, Device)) -> Tensor
[src]
pub fn ones_out(result: &Tensor, size: &[i64]) -> Tensor
[src]
pub fn orgqr(&self, input2: &Tensor) -> Tensor
[src]
pub fn orgqr_out(&self, result: &Tensor, input2: &Tensor) -> Tensor
[src]
pub fn ormqr(
&self,
input2: &Tensor,
input3: &Tensor,
left: bool,
transpose: bool
) -> Tensor
[src]
&self,
input2: &Tensor,
input3: &Tensor,
left: bool,
transpose: bool
) -> Tensor
pub fn ormqr_out(
&self,
result: &Tensor,
input2: &Tensor,
input3: &Tensor,
left: bool,
transpose: bool
) -> Tensor
[src]
&self,
result: &Tensor,
input2: &Tensor,
input3: &Tensor,
left: bool,
transpose: bool
) -> Tensor
pub fn pairwise_distance(
x1: &Tensor,
x2: &Tensor,
p: f64,
eps: f64,
keepdim: bool
) -> Tensor
[src]
x1: &Tensor,
x2: &Tensor,
p: f64,
eps: f64,
keepdim: bool
) -> Tensor
pub fn pdist(&self, p: f64) -> Tensor
[src]
pub fn permute(&self, dims: &[i64]) -> Tensor
[src]
pub fn pin_memory(&self) -> Tensor
[src]
pub fn pinverse(&self, rcond: f64) -> Tensor
[src]
pub fn pixel_shuffle(&self, upscale_factor: i64) -> Tensor
[src]
pub fn poisson(&self) -> Tensor
[src]
pub fn polygamma(&self, n: i64) -> Tensor
[src]
pub fn polygamma_(&self, n: i64) -> Tensor
[src]
pub fn polygamma_out(&self, result: &Tensor, n: i64) -> Tensor
[src]
pub fn potri(&self, upper: bool) -> Tensor
[src]
pub fn potri_out(&self, result: &Tensor, upper: bool) -> Tensor
[src]
pub fn potrs(&self, input2: &Tensor, upper: bool) -> Tensor
[src]
pub fn potrs_out(&self, result: &Tensor, input2: &Tensor, upper: bool) -> Tensor
[src]
pub fn pow<S: Into<Scalar>>(&self, exponent: S) -> Tensor
[src]
pub fn pow1(&self, exponent: &Tensor) -> Tensor
[src]
pub fn pow2<S: Into<Scalar>>(self_scalar: S, exponent: &Tensor) -> Tensor
[src]
pub fn pow_<S: Into<Scalar>>(&self, exponent: S) -> Tensor
[src]
pub fn pow_1(&self, exponent: &Tensor) -> Tensor
[src]
pub fn pow_out<S: Into<Scalar>>(&self, result: &Tensor, exponent: S) -> Tensor
[src]
pub fn pow_out1(&self, result: &Tensor, exponent: &Tensor) -> Tensor
[src]
pub fn pow_out2<S: Into<Scalar>>(
result: &Tensor,
self_scalar: S,
exponent: &Tensor
) -> Tensor
[src]
result: &Tensor,
self_scalar: S,
exponent: &Tensor
) -> Tensor
pub fn prelu(&self, weight: &Tensor) -> Tensor
[src]
pub fn prelu_backward(
&self,
grad_output: &Tensor,
weight: &Tensor
) -> (Tensor, Tensor)
[src]
&self,
grad_output: &Tensor,
weight: &Tensor
) -> (Tensor, Tensor)
pub fn prod(&self) -> Tensor
[src]
pub fn prod1(&self, dtype: Kind) -> Tensor
[src]
pub fn prod2(&self, dim: i64, keepdim: bool) -> Tensor
[src]
pub fn prod3(&self, dim: i64, dtype: Kind) -> Tensor
[src]
pub fn prod4(&self, dim: i64, keepdim: bool, dtype: Kind) -> Tensor
[src]
pub fn prod_out(&self, result: &Tensor, dim: i64, keepdim: bool) -> Tensor
[src]
pub fn prod_out1(&self, result: &Tensor, dim: i64, dtype: Kind) -> Tensor
[src]
pub fn prod_out2(
&self,
result: &Tensor,
dim: i64,
keepdim: bool,
dtype: Kind
) -> Tensor
[src]
&self,
result: &Tensor,
dim: i64,
keepdim: bool,
dtype: Kind
) -> Tensor
pub fn pstrf(&self, upper: bool) -> (Tensor, Tensor)
[src]
pub fn pstrf_out(
&self,
u: &Tensor,
piv: &Tensor,
upper: bool
) -> (Tensor, Tensor)
[src]
&self,
u: &Tensor,
piv: &Tensor,
upper: bool
) -> (Tensor, Tensor)
pub fn put_(&self, index: &Tensor, source: &Tensor, accumulate: bool) -> Tensor
[src]
pub fn qr(&self) -> (Tensor, Tensor)
[src]
pub fn qr_out(&self, q: &Tensor, r: &Tensor) -> (Tensor, Tensor)
[src]
pub fn rand(size: &[i64], options: (Kind, Device)) -> Tensor
[src]
pub fn rand_like(&self) -> Tensor
[src]
pub fn rand_like1(&self, options: (Kind, Device)) -> Tensor
[src]
pub fn rand_out(result: &Tensor, size: &[i64]) -> Tensor
[src]
pub fn randint(high: i64, size: &[i64], options: (Kind, Device)) -> Tensor
[src]
pub fn randint1(
low: i64,
high: i64,
size: &[i64],
options: (Kind, Device)
) -> Tensor
[src]
low: i64,
high: i64,
size: &[i64],
options: (Kind, Device)
) -> Tensor
pub fn randint_like(&self, high: i64) -> Tensor
[src]
pub fn randint_like1(&self, low: i64, high: i64) -> Tensor
[src]
pub fn randint_like2(&self, high: i64, options: (Kind, Device)) -> Tensor
[src]
pub fn randint_like3(
&self,
low: i64,
high: i64,
options: (Kind, Device)
) -> Tensor
[src]
&self,
low: i64,
high: i64,
options: (Kind, Device)
) -> Tensor
pub fn randint_out(result: &Tensor, high: i64, size: &[i64]) -> Tensor
[src]
pub fn randint_out1(
result: &Tensor,
low: i64,
high: i64,
size: &[i64]
) -> Tensor
[src]
result: &Tensor,
low: i64,
high: i64,
size: &[i64]
) -> Tensor
pub fn randn(size: &[i64], options: (Kind, Device)) -> Tensor
[src]
pub fn randn_like(&self) -> Tensor
[src]
pub fn randn_like1(&self, options: (Kind, Device)) -> Tensor
[src]
pub fn randn_out(result: &Tensor, size: &[i64]) -> Tensor
[src]
pub fn random_(&self) -> Tensor
[src]
pub fn random_1(&self, to_: i64) -> Tensor
[src]
pub fn random_2(&self, from: i64, to_: i64) -> Tensor
[src]
pub fn randperm(n: i64, options: (Kind, Device)) -> Tensor
[src]
pub fn randperm_out(result: &Tensor, n: i64) -> Tensor
[src]
pub fn range<S: Into<Scalar>>(
start: S,
end_: S,
options: (Kind, Device)
) -> Tensor
[src]
start: S,
end_: S,
options: (Kind, Device)
) -> Tensor
pub fn range1<S: Into<Scalar>>(
start: S,
end_: S,
step: S,
options: (Kind, Device)
) -> Tensor
[src]
start: S,
end_: S,
step: S,
options: (Kind, Device)
) -> Tensor
pub fn range_out<S: Into<Scalar>>(result: &Tensor, start: S, end_: S) -> Tensor
[src]
pub fn range_out1<S: Into<Scalar>>(
result: &Tensor,
start: S,
end_: S,
step: S
) -> Tensor
[src]
result: &Tensor,
start: S,
end_: S,
step: S
) -> Tensor
pub fn reciprocal(&self) -> Tensor
[src]
pub fn reciprocal_(&self) -> Tensor
[src]
pub fn reciprocal_out(&self, result: &Tensor) -> Tensor
[src]
pub fn reflection_pad1d(&self, padding: &[i64]) -> Tensor
[src]
pub fn reflection_pad1d_backward(
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
[src]
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
pub fn reflection_pad1d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
pub fn reflection_pad1d_out(&self, output: &Tensor, padding: &[i64]) -> Tensor
[src]
pub fn reflection_pad2d(&self, padding: &[i64]) -> Tensor
[src]
pub fn reflection_pad2d_backward(
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
[src]
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
pub fn reflection_pad2d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
pub fn reflection_pad2d_out(&self, output: &Tensor, padding: &[i64]) -> Tensor
[src]
pub fn relu(&self) -> Tensor
[src]
pub fn relu_(&self) -> Tensor
[src]
pub fn remainder<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn remainder1(&self, other: &Tensor) -> Tensor
[src]
pub fn remainder_<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn remainder_1(&self, other: &Tensor) -> Tensor
[src]
pub fn remainder_out<S: Into<Scalar>>(
&self,
result: &Tensor,
other: S
) -> Tensor
[src]
&self,
result: &Tensor,
other: S
) -> Tensor
pub fn remainder_out1(&self, result: &Tensor, other: &Tensor) -> Tensor
[src]
pub fn renorm<S: Into<Scalar>>(&self, p: S, dim: i64, maxnorm: S) -> Tensor
[src]
pub fn renorm_<S: Into<Scalar>>(&self, p: S, dim: i64, maxnorm: S) -> Tensor
[src]
pub fn renorm_out<S: Into<Scalar>>(
&self,
result: &Tensor,
p: S,
dim: i64,
maxnorm: S
) -> Tensor
[src]
&self,
result: &Tensor,
p: S,
dim: i64,
maxnorm: S
) -> Tensor
pub fn repeat(&self, repeats: &[i64]) -> Tensor
[src]
pub fn replication_pad1d(&self, padding: &[i64]) -> Tensor
[src]
pub fn replication_pad1d_backward(
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
[src]
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
pub fn replication_pad1d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
pub fn replication_pad1d_out(&self, output: &Tensor, padding: &[i64]) -> Tensor
[src]
pub fn replication_pad2d(&self, padding: &[i64]) -> Tensor
[src]
pub fn replication_pad2d_backward(
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
[src]
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
pub fn replication_pad2d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
pub fn replication_pad2d_out(&self, output: &Tensor, padding: &[i64]) -> Tensor
[src]
pub fn replication_pad3d(&self, padding: &[i64]) -> Tensor
[src]
pub fn replication_pad3d_backward(
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
[src]
&self,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
pub fn replication_pad3d_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
padding: &[i64]
) -> Tensor
pub fn replication_pad3d_out(&self, output: &Tensor, padding: &[i64]) -> Tensor
[src]
pub fn reshape(&self, shape: &[i64]) -> Tensor
[src]
pub fn reshape_as(&self, other: &Tensor) -> Tensor
[src]
pub fn resize_(&self, size: &[i64]) -> Tensor
[src]
pub fn resize_as_(&self, the_template: &Tensor) -> Tensor
[src]
pub fn rfft(&self, signal_ndim: i64, normalized: bool, onesided: bool) -> Tensor
[src]
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)
[src]
&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_relu1<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)
[src]
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_relu_cell<T: Borrow<Tensor>>(
&self,
hx: &Tensor,
w_ih: &Tensor,
w_hh: &Tensor,
b_ih: Option<T>,
b_hh: Option<T>
) -> Tensor
[src]
&self,
hx: &Tensor,
w_ih: &Tensor,
w_hh: &Tensor,
b_ih: Option<T>,
b_hh: Option<T>
) -> 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)
[src]
&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_tanh1<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)
[src]
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_cell<T: Borrow<Tensor>>(
&self,
hx: &Tensor,
w_ih: &Tensor,
w_hh: &Tensor,
b_ih: Option<T>,
b_hh: Option<T>
) -> Tensor
[src]
&self,
hx: &Tensor,
w_ih: &Tensor,
w_hh: &Tensor,
b_ih: Option<T>,
b_hh: Option<T>
) -> Tensor
pub fn roipooling2d_backward(
&self,
rois: &Tensor,
pooledheight: i64,
pooledwidth: i64,
spatialscale: f64,
gradoutput: &Tensor,
argmaxes: &Tensor
) -> Tensor
[src]
&self,
rois: &Tensor,
pooledheight: i64,
pooledwidth: i64,
spatialscale: f64,
gradoutput: &Tensor,
argmaxes: &Tensor
) -> Tensor
pub fn roll(&self, shifts: &[i64], dims: &[i64]) -> Tensor
[src]
pub fn rot90(&self, k: i64, dims: &[i64]) -> Tensor
[src]
pub fn round(&self) -> Tensor
[src]
pub fn round_(&self) -> Tensor
[src]
pub fn round_out(&self, result: &Tensor) -> Tensor
[src]
pub fn rrelu(&self, training: bool) -> Tensor
[src]
pub fn rrelu_(&self, training: bool) -> Tensor
[src]
pub fn rrelu_with_noise(&self, noise: &Tensor, training: bool) -> Tensor
[src]
pub fn rrelu_with_noise_(&self, noise: &Tensor, training: bool) -> Tensor
[src]
pub fn rrelu_with_noise_out(
&self,
output: &Tensor,
noise: &Tensor,
training: bool
) -> Tensor
[src]
&self,
output: &Tensor,
noise: &Tensor,
training: bool
) -> Tensor
pub fn rsqrt(&self) -> Tensor
[src]
pub fn rsqrt_(&self) -> Tensor
[src]
pub fn rsqrt_out(&self, result: &Tensor) -> Tensor
[src]
pub fn rsub(&self, other: &Tensor) -> Tensor
[src]
pub fn rsub1<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn s_native_addmm(&self, mat1: &Tensor, mat2: &Tensor) -> Tensor
[src]
pub fn s_native_addmm_(&self, mat1: &Tensor, mat2: &Tensor) -> Tensor
[src]
pub fn s_native_addmm_out(
&self,
result: &Tensor,
mat1: &Tensor,
mat2: &Tensor
) -> Tensor
[src]
&self,
result: &Tensor,
mat1: &Tensor,
mat2: &Tensor
) -> Tensor
pub fn scatter_(&self, dim: i64, index: &Tensor, src: &Tensor) -> Tensor
[src]
pub fn scatter_1<S: Into<Scalar>>(
&self,
dim: i64,
index: &Tensor,
value: S
) -> Tensor
[src]
&self,
dim: i64,
index: &Tensor,
value: S
) -> Tensor
pub fn scatter_add_(&self, dim: i64, index: &Tensor, src: &Tensor) -> Tensor
[src]
pub fn select(&self, dim: i64, index: i64) -> Tensor
[src]
pub fn selu(&self) -> Tensor
[src]
pub fn selu_(&self) -> Tensor
[src]
pub fn set_(&self) -> Tensor
[src]
pub fn set_1(&self, source: &Tensor) -> Tensor
[src]
pub fn set_requires_grad(&self, r: bool) -> Tensor
[src]
pub fn sigmoid(&self) -> Tensor
[src]
pub fn sigmoid_(&self) -> Tensor
[src]
pub fn sigmoid_out(&self, result: &Tensor) -> Tensor
[src]
pub fn sign(&self) -> Tensor
[src]
pub fn sign_(&self) -> Tensor
[src]
pub fn sign_out(&self, result: &Tensor) -> Tensor
[src]
pub fn sin(&self) -> Tensor
[src]
pub fn sin_(&self) -> Tensor
[src]
pub fn sin_out(&self, result: &Tensor) -> Tensor
[src]
pub fn sinh(&self) -> Tensor
[src]
pub fn sinh_(&self) -> Tensor
[src]
pub fn sinh_out(&self, result: &Tensor) -> Tensor
[src]
pub fn slice(&self, dim: i64, start: i64, end_: i64, step: i64) -> Tensor
[src]
pub fn slogdet(&self) -> (Tensor, Tensor)
[src]
pub fn smm(&self, mat2: &Tensor) -> Tensor
[src]
pub fn smooth_l1_loss(&self, target: &Tensor, reduction: i64) -> Tensor
[src]
pub fn smooth_l1_loss_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
[src]
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
pub fn smooth_l1_loss_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
pub fn smooth_l1_loss_out(
&self,
output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
[src]
&self,
output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
pub fn soft_margin_loss(&self, target: &Tensor, reduction: i64) -> Tensor
[src]
pub fn soft_margin_loss_backward(
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
[src]
&self,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
pub fn soft_margin_loss_backward_out(
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
[src]
&self,
grad_input: &Tensor,
grad_output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
pub fn soft_margin_loss_out(
&self,
output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
[src]
&self,
output: &Tensor,
target: &Tensor,
reduction: i64
) -> Tensor
pub fn softmax(&self, dim: i64) -> Tensor
[src]
pub fn softmax1(&self, dim: i64, dtype: Kind) -> Tensor
[src]
pub fn softplus(&self) -> Tensor
[src]
pub fn softplus_out(&self, output: &Tensor) -> Tensor
[src]
pub fn softshrink(&self) -> Tensor
[src]
pub fn softshrink_out(&self, output: &Tensor) -> Tensor
[src]
pub fn sort(&self, dim: i64, descending: bool) -> (Tensor, Tensor)
[src]
pub fn sort_out(
&self,
values: &Tensor,
indices: &Tensor,
dim: i64,
descending: bool
) -> (Tensor, Tensor)
[src]
&self,
values: &Tensor,
indices: &Tensor,
dim: i64,
descending: bool
) -> (Tensor, Tensor)
pub fn sparse_coo_tensor(size: &[i64], options: (Kind, Device)) -> Tensor
[src]
pub fn sparse_coo_tensor1(
indices: &Tensor,
values: &Tensor,
options: (Kind, Device)
) -> Tensor
[src]
indices: &Tensor,
values: &Tensor,
options: (Kind, Device)
) -> Tensor
pub fn sparse_coo_tensor2(
indices: &Tensor,
values: &Tensor,
size: &[i64],
options: (Kind, Device)
) -> Tensor
[src]
indices: &Tensor,
values: &Tensor,
size: &[i64],
options: (Kind, Device)
) -> Tensor
pub fn sparse_resize_(
&self,
size: &[i64],
sparse_dim: i64,
dense_dim: i64
) -> Tensor
[src]
&self,
size: &[i64],
sparse_dim: i64,
dense_dim: i64
) -> Tensor
pub fn sparse_resize_and_clear_(
&self,
size: &[i64],
sparse_dim: i64,
dense_dim: i64
) -> Tensor
[src]
&self,
size: &[i64],
sparse_dim: i64,
dense_dim: i64
) -> Tensor
pub fn sqrt(&self) -> Tensor
[src]
pub fn sqrt_(&self) -> Tensor
[src]
pub fn sqrt_out(&self, result: &Tensor) -> Tensor
[src]
pub fn squeeze(&self) -> Tensor
[src]
pub fn squeeze1(&self, dim: i64) -> Tensor
[src]
pub fn squeeze_(&self) -> Tensor
[src]
pub fn squeeze_1(&self, dim: i64) -> Tensor
[src]
pub fn sspaddmm(&self, mat1: &Tensor, mat2: &Tensor) -> Tensor
[src]
pub fn sspaddmm_out(
&self,
result: &Tensor,
mat1: &Tensor,
mat2: &Tensor
) -> Tensor
[src]
&self,
result: &Tensor,
mat1: &Tensor,
mat2: &Tensor
) -> Tensor
pub fn stack<T: Borrow<Tensor>>(tensors: &[T], dim: i64) -> Tensor
[src]
pub fn stack_out<T: Borrow<Tensor>>(
result: &Tensor,
tensors: &[T],
dim: i64
) -> Tensor
[src]
result: &Tensor,
tensors: &[T],
dim: i64
) -> Tensor
pub fn std(&self, unbiased: bool) -> Tensor
[src]
pub fn std1(&self, dim: i64, unbiased: bool, keepdim: bool) -> Tensor
[src]
pub fn std_out(
&self,
result: &Tensor,
dim: i64,
unbiased: bool,
keepdim: bool
) -> Tensor
[src]
&self,
result: &Tensor,
dim: i64,
unbiased: bool,
keepdim: bool
) -> Tensor
pub fn stft<T: Borrow<Tensor>>(
&self,
n_fft: i64,
hop_length: i64,
win_length: i64,
window: Option<T>,
normalized: bool,
onesided: bool
) -> Tensor
[src]
&self,
n_fft: i64,
hop_length: i64,
win_length: i64,
window: Option<T>,
normalized: bool,
onesided: bool
) -> Tensor
pub fn g_sub(&self, other: &Tensor) -> Tensor
[src]
pub fn g_sub1<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn g_sub_(&self, other: &Tensor) -> Tensor
[src]
pub fn g_sub_1<S: Into<Scalar>>(&self, other: S) -> Tensor
[src]
pub fn sub_out(&self, result: &Tensor, other: &Tensor) -> Tensor
[src]
pub fn sum(&self) -> Tensor
[src]
pub fn sum1(&self, dtype: Kind) -> Tensor
[src]
pub fn sum2(&self, dim: &[i64], keepdim: bool) -> Tensor
[src]
pub fn sum3(&self, dim: &[i64], dtype: Kind) -> Tensor
[src]
pub fn sum4(&self, dim: &[i64], keepdim: bool, dtype: Kind) -> Tensor
[src]
pub fn sum_out(&self, result: &Tensor, dim: &[i64], keepdim: bool) -> Tensor
[src]
pub fn sum_out1(&self, result: &Tensor, dim: &[i64], dtype: Kind) -> Tensor
[src]
pub fn sum_out2(
&self,
result: &Tensor,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Tensor
[src]
&self,
result: &Tensor,
dim: &[i64],
keepdim: bool,
dtype: Kind
) -> Tensor
pub fn svd(&self, some: bool, compute_uv: bool) -> (Tensor, Tensor, Tensor)
[src]
pub fn svd_out(
&self,
u: &Tensor,
s: &Tensor,
v: &Tensor,
some: bool,
compute_uv: bool
) -> (Tensor, Tensor, Tensor)
[src]
&self,
u: &Tensor,
s: &Tensor,
v: &Tensor,
some: bool,
compute_uv: bool
) -> (Tensor, Tensor, Tensor)
pub fn symeig(&self, eigenvectors: bool, upper: bool) -> (Tensor, Tensor)
[src]
pub fn symeig_out(
&self,
e: &Tensor,
v: &Tensor,
eigenvectors: bool,
upper: bool
) -> (Tensor, Tensor)
[src]
&self,
e: &Tensor,
v: &Tensor,
eigenvectors: bool,
upper: bool
) -> (Tensor, Tensor)
pub fn tr(&self) -> Tensor
[src]
pub fn t_(&self) -> Tensor
[src]
pub fn take(&self, index: &Tensor) -> Tensor
[src]
pub fn take_out(&self, result: &Tensor, index: &Tensor) -> Tensor
[src]
pub fn tan(&self) -> Tensor
[src]
pub fn tan_(&self) -> Tensor
[src]
pub fn tan_out(&self, result: &Tensor) -> Tensor
[src]
pub fn tanh(&self) -> Tensor
[src]
pub fn tanh_(&self) -> Tensor
[src]
pub fn tanh_out(&self, result: &Tensor) -> Tensor
[src]
pub fn tensordot(
&self,
other: &Tensor,
dims_self: &[i64],
dims_other: &[i64]
) -> Tensor
[src]
&self,
other: &Tensor,
dims_self: &[i64],
dims_other: &[i64]
) -> Tensor
pub fn threshold<S: Into<Scalar>>(&self, threshold: S, value: S) -> Tensor
[src]
pub fn threshold_<S: Into<Scalar>>(&self, threshold: S, value: S) -> Tensor
[src]
pub fn threshold_backward<S: Into<Scalar>>(
&self,
grad_output: &Tensor,
threshold: S
) -> Tensor
[src]
&self,
grad_output: &Tensor,
threshold: S
) -> Tensor
pub fn threshold_out<S: Into<Scalar>>(
&self,
result: &Tensor,
threshold: S,
value: S
) -> Tensor
[src]
&self,
result: &Tensor,
threshold: S,
value: S
) -> Tensor
pub fn to_(&self, device: Device) -> Tensor
[src]
pub fn to1(
&self,
options: (Kind, Device),
non_blocking: bool,
copy: bool
) -> Tensor
[src]
&self,
options: (Kind, Device),
non_blocking: bool,
copy: bool
) -> Tensor
pub fn to2(&self, dtype: Kind, non_blocking: bool, copy: bool) -> Tensor
[src]
pub fn to3(&self, other: &Tensor, non_blocking: bool, copy: bool) -> Tensor
[src]
pub fn to4(
&self,
device: Device,
dtype: Kind,
non_blocking: bool,
copy: bool
) -> Tensor
[src]
&self,
device: Device,
dtype: Kind,
non_blocking: bool,
copy: bool
) -> Tensor
pub fn to_dense(&self) -> Tensor
[src]
pub fn to_sparse(&self) -> Tensor
[src]
pub fn to_sparse1(&self, sparse_dim: i64) -> Tensor
[src]
pub fn topk(
&self,
k: i64,
dim: i64,
largest: bool,
sorted: bool
) -> (Tensor, Tensor)
[src]
&self,
k: i64,
dim: i64,
largest: bool,
sorted: bool
) -> (Tensor, Tensor)
pub fn topk_out(
&self,
values: &Tensor,
indices: &Tensor,
k: i64,
dim: i64,
largest: bool,
sorted: bool
) -> (Tensor, Tensor)
[src]
&self,
values: &Tensor,
indices: &Tensor,
k: i64,
dim: i64,
largest: bool,
sorted: bool
) -> (Tensor, Tensor)
pub fn totype(&self, scalar_type: Kind) -> Tensor
[src]
pub fn trace(&self) -> Tensor
[src]
pub fn transpose(&self, dim0: i64, dim1: i64) -> Tensor
[src]
pub fn transpose_(&self, dim0: i64, dim1: i64) -> Tensor
[src]
pub fn tril(&self, diagonal: i64) -> Tensor
[src]
pub fn tril_(&self, diagonal: i64) -> Tensor
[src]
pub fn tril_out(&self, result: &Tensor, diagonal: i64) -> Tensor
[src]
pub fn triplet_margin_loss(
anchor: &Tensor,
positive: &Tensor,
negative: &Tensor,
margin: f64,
p: f64,
eps: f64,
swap: bool,
reduction: i64
) -> Tensor
[src]
anchor: &Tensor,
positive: &Tensor,
negative: &Tensor,
margin: f64,
p: f64,
eps: f64,
swap: bool,
reduction: i64
) -> Tensor
pub fn triu(&self, diagonal: i64) -> Tensor
[src]
pub fn triu_(&self, diagonal: i64) -> Tensor
[src]
pub fn triu_out(&self, result: &Tensor, diagonal: i64) -> Tensor
[src]
pub fn trtrs(
&self,
a: &Tensor,
upper: bool,
transpose: bool,
unitriangular: bool
) -> (Tensor, Tensor)
[src]
&self,
a: &Tensor,
upper: bool,
transpose: bool,
unitriangular: bool
) -> (Tensor, Tensor)
pub fn trtrs_out(
&self,
x: &Tensor,
m: &Tensor,
a: &Tensor,
upper: bool,
transpose: bool,
unitriangular: bool
) -> (Tensor, Tensor)
[src]
&self,
x: &Tensor,
m: &Tensor,
a: &Tensor,
upper: bool,
transpose: bool,
unitriangular: bool
) -> (Tensor, Tensor)
pub fn trunc(&self) -> Tensor
[src]
pub fn trunc_(&self) -> Tensor
[src]
pub fn trunc_out(&self, result: &Tensor) -> Tensor
[src]
pub fn type_as(&self, other: &Tensor) -> Tensor
[src]
pub fn unfold(&self, dimension: i64, size: i64, step: i64) -> Tensor
[src]
pub fn uniform_(&self, from: f64, to_: f64) -> Tensor
[src]
pub fn unsqueeze(&self, dim: i64) -> Tensor
[src]
pub fn unsqueeze_(&self, dim: i64) -> Tensor
[src]
pub fn upsample_bilinear2d(
&self,
output_size: &[i64],
align_corners: bool
) -> Tensor
[src]
&self,
output_size: &[i64],
align_corners: bool
) -> Tensor
pub fn upsample_bilinear2d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Tensor
[src]
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Tensor
pub fn upsample_bilinear2d_backward_out(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Tensor
[src]
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Tensor
pub fn upsample_bilinear2d_out(
&self,
output: &Tensor,
output_size: &[i64],
align_corners: bool
) -> Tensor
[src]
&self,
output: &Tensor,
output_size: &[i64],
align_corners: bool
) -> Tensor
pub fn upsample_linear1d(
&self,
output_size: &[i64],
align_corners: bool
) -> Tensor
[src]
&self,
output_size: &[i64],
align_corners: bool
) -> Tensor
pub fn upsample_linear1d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Tensor
[src]
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Tensor
pub fn upsample_linear1d_backward_out(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Tensor
[src]
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Tensor
pub fn upsample_linear1d_out(
&self,
output: &Tensor,
output_size: &[i64],
align_corners: bool
) -> Tensor
[src]
&self,
output: &Tensor,
output_size: &[i64],
align_corners: bool
) -> Tensor
pub fn upsample_nearest1d(&self, output_size: &[i64]) -> Tensor
[src]
pub fn upsample_nearest1d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Tensor
[src]
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Tensor
pub fn upsample_nearest1d_backward_out(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Tensor
[src]
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Tensor
pub fn upsample_nearest1d_out(
&self,
output: &Tensor,
output_size: &[i64]
) -> Tensor
[src]
&self,
output: &Tensor,
output_size: &[i64]
) -> Tensor
pub fn upsample_nearest2d(&self, output_size: &[i64]) -> Tensor
[src]
pub fn upsample_nearest2d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Tensor
[src]
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Tensor
pub fn upsample_nearest2d_backward_out(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Tensor
[src]
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Tensor
pub fn upsample_nearest2d_out(
&self,
output: &Tensor,
output_size: &[i64]
) -> Tensor
[src]
&self,
output: &Tensor,
output_size: &[i64]
) -> Tensor
pub fn upsample_nearest3d(&self, output_size: &[i64]) -> Tensor
[src]
pub fn upsample_nearest3d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Tensor
[src]
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Tensor
pub fn upsample_nearest3d_backward_out(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Tensor
[src]
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64]
) -> Tensor
pub fn upsample_nearest3d_out(
&self,
output: &Tensor,
output_size: &[i64]
) -> Tensor
[src]
&self,
output: &Tensor,
output_size: &[i64]
) -> Tensor
pub fn upsample_trilinear3d(
&self,
output_size: &[i64],
align_corners: bool
) -> Tensor
[src]
&self,
output_size: &[i64],
align_corners: bool
) -> Tensor
pub fn upsample_trilinear3d_backward(
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Tensor
[src]
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Tensor
pub fn upsample_trilinear3d_backward_out(
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Tensor
[src]
grad_input: &Tensor,
grad_output: &Tensor,
output_size: &[i64],
input_size: &[i64],
align_corners: bool
) -> Tensor
pub fn upsample_trilinear3d_out(
&self,
output: &Tensor,
output_size: &[i64],
align_corners: bool
) -> Tensor
[src]
&self,
output: &Tensor,
output_size: &[i64],
align_corners: bool
) -> Tensor
pub fn values(&self) -> Tensor
[src]
pub fn var(&self, unbiased: bool) -> Tensor
[src]
pub fn var1(&self, dim: i64, unbiased: bool, keepdim: bool) -> Tensor
[src]
pub fn var_out(
&self,
result: &Tensor,
dim: i64,
unbiased: bool,
keepdim: bool
) -> Tensor
[src]
&self,
result: &Tensor,
dim: i64,
unbiased: bool,
keepdim: bool
) -> Tensor
pub fn view(&self, size: &[i64]) -> Tensor
[src]
pub fn view_as(&self, other: &Tensor) -> Tensor
[src]
pub fn where_(&self, condition: &Tensor, other: &Tensor) -> Tensor
[src]
pub fn zero_(&self) -> Tensor
[src]
pub fn zeros(size: &[i64], options: (Kind, Device)) -> Tensor
[src]
pub fn zeros_like(&self) -> Tensor
[src]
pub fn zeros_like1(&self, options: (Kind, Device)) -> Tensor
[src]
pub fn zeros_out(result: &Tensor, size: &[i64]) -> Tensor
[src]
impl Tensor
[src]
impl Tensor
[src]
pub fn read_npy<T: AsRef<Path>>(path: T) -> Fallible<Tensor>
[src]
Reads a npy file and return the stored tensor.
pub fn read_npz<T: AsRef<Path>>(path: T) -> Fallible<Vec<(String, Tensor)>>
[src]
Reads a npz file and returns some named tensors.
pub fn write_npy<T: AsRef<Path>>(&self, path: T) -> Fallible<()>
[src]
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
) -> Fallible<()>
[src]
ts: &[(S, T)],
path: P
) -> Fallible<()>
impl Tensor
[src]
pub fn to_kind(&self, kind: Kind) -> Tensor
[src]
Casts a tensor to a specified kind.
pub fn f_to_kind(&self, kind: Kind) -> Fallible<Tensor>
[src]
pub fn nll_loss(&self, targets: &Tensor) -> Tensor
[src]
impl Tensor
[src]
pub fn cross_entropy_for_logits(&self, targets: &Tensor) -> Tensor
[src]
Computes the cross-entropy loss based on some logits and targets.
pub fn accuracy_for_logits(&self, targets: &Tensor) -> Tensor
[src]
Returns the average accuracy for some given logits assuming that targets represent ground-truth.
pub fn random_batch(&self, batch_size: i64) -> Tensor
[src]
pub fn random_batch2(
t1: &Tensor,
t2: &Tensor,
batch_size: i64,
device: Device
) -> (Tensor, Tensor)
[src]
t1: &Tensor,
t2: &Tensor,
batch_size: i64,
device: Device
) -> (Tensor, Tensor)
pub fn to_device(&self, device: Device) -> Tensor
[src]
Moves a tensor to a specified device.
pub fn f_to_device(&self, device: Device) -> Fallible<Tensor>
[src]
pub fn avg_pool2d_default(&self, ksize: i64) -> Tensor
[src]
pub fn max_pool2d_default(&self, ksize: i64) -> Tensor
[src]
pub fn flat_view(&self) -> Tensor
[src]
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.
pub fn onehot(&self, labels: i64) -> Tensor
[src]
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.
pub fn copy(&self) -> Tensor
[src]
Copies a tensor to a newly allocated tensor using the same shape and device.
impl Tensor
[src]
impl Tensor
[src]
pub fn apply<M: Module>(&self, m: &M) -> Tensor
[src]
pub fn apply_t<M: ModuleT>(&self, m: &M, train: bool) -> Tensor
[src]
pub fn apply_opt<M: Module>(&self, m: &Option<M>) -> Tensor
[src]
pub fn apply_opt_t<M: ModuleT>(&self, m: &Option<M>, train: bool) -> Tensor
[src]
Trait Implementations
impl Drop for Tensor
[src]
impl AsRef<Tensor> for Tensor
[src]
impl Default for Tensor
[src]
impl<T: T, '_> From<&'_ [T]> for Tensor
[src]
impl<T: T> From<T> for Tensor
[src]
impl<'_> From<&'_ Tensor> for Vec<f64>
[src]
impl<'_> From<&'_ Tensor> for Vec<Vec<f64>>
[src]
impl<'_> From<&'_ Tensor> for Vec<Vec<Vec<f64>>>
[src]
impl<'_> From<&'_ Tensor> for f64
[src]
impl From<Tensor> for Vec<f64>
[src]
impl From<Tensor> for Vec<Vec<f64>>
[src]
impl From<Tensor> for Vec<Vec<Vec<f64>>>
[src]
impl From<Tensor> for f64
[src]
impl<'_> From<&'_ Tensor> for Vec<f32>
[src]
impl<'_> From<&'_ Tensor> for Vec<Vec<f32>>
[src]
impl<'_> From<&'_ Tensor> for Vec<Vec<Vec<f32>>>
[src]
impl<'_> From<&'_ Tensor> for f32
[src]
impl From<Tensor> for Vec<f32>
[src]
impl From<Tensor> for Vec<Vec<f32>>
[src]
impl From<Tensor> for Vec<Vec<Vec<f32>>>
[src]
impl From<Tensor> for f32
[src]
impl<'_> From<&'_ Tensor> for Vec<i64>
[src]
impl<'_> From<&'_ Tensor> for Vec<Vec<i64>>
[src]
impl<'_> From<&'_ Tensor> for Vec<Vec<Vec<i64>>>
[src]
impl<'_> From<&'_ Tensor> for i64
[src]
impl From<Tensor> for Vec<i64>
[src]
impl From<Tensor> for Vec<Vec<i64>>
[src]
impl From<Tensor> for Vec<Vec<Vec<i64>>>
[src]
impl From<Tensor> for i64
[src]
impl<'_> From<&'_ Tensor> for Vec<i32>
[src]
impl<'_> From<&'_ Tensor> for Vec<Vec<i32>>
[src]
impl<'_> From<&'_ Tensor> for Vec<Vec<Vec<i32>>>
[src]
impl<'_> From<&'_ Tensor> for i32
[src]
impl From<Tensor> for Vec<i32>
[src]
impl From<Tensor> for Vec<Vec<i32>>
[src]
impl From<Tensor> for Vec<Vec<Vec<i32>>>
[src]
impl From<Tensor> for i32
[src]
impl<'_> From<&'_ Tensor> for Vec<i8>
[src]
impl<'_> From<&'_ Tensor> for Vec<Vec<i8>>
[src]
impl<'_> From<&'_ Tensor> for Vec<Vec<Vec<i8>>>
[src]
impl<'_> From<&'_ Tensor> for i8
[src]
impl From<Tensor> for Vec<i8>
[src]
impl From<Tensor> for Vec<Vec<i8>>
[src]
impl From<Tensor> for Vec<Vec<Vec<i8>>>
[src]
impl From<Tensor> for i8
[src]
impl<'_> From<&'_ Tensor> for Vec<u8>
[src]
impl<'_> From<&'_ Tensor> for Vec<Vec<u8>>
[src]
impl<'_> From<&'_ Tensor> for Vec<Vec<Vec<u8>>>
[src]
impl<'_> From<&'_ Tensor> for u8
[src]
impl From<Tensor> for Vec<u8>
[src]
impl From<Tensor> for Vec<Vec<u8>>
[src]
impl From<Tensor> for Vec<Vec<Vec<u8>>>
[src]
impl From<Tensor> for u8
[src]
impl Send for Tensor
[src]
impl Debug for Tensor
[src]
impl Add<Tensor> for Tensor
[src]
type Output = Tensor
The resulting type after applying the +
operator.
fn add(self, rhs: Tensor) -> Self::Output
[src]
impl<'_> Add<&'_ Tensor> for Tensor
[src]
type Output = Tensor
The resulting type after applying the +
operator.
fn add(self, rhs: &Tensor) -> Self::Output
[src]
impl<'a, '_> Add<&'_ Tensor> for &'a Tensor
[src]
type Output = Tensor
The resulting type after applying the +
operator.
fn add(self, rhs: &Tensor) -> Self::Output
[src]
impl<'_> Add<Tensor> for &'_ Tensor
[src]
type Output = Tensor
The resulting type after applying the +
operator.
fn add(self, rhs: Tensor) -> Self::Output
[src]
impl Add<i64> for Tensor
[src]
type Output = Tensor
The resulting type after applying the +
operator.
fn add(self, rhs: i64) -> Self::Output
[src]
impl Add<f64> for Tensor
[src]
type Output = Tensor
The resulting type after applying the +
operator.
fn add(self, rhs: f64) -> Self::Output
[src]
impl<'_> Add<i64> for &'_ Tensor
[src]
type Output = Tensor
The resulting type after applying the +
operator.
fn add(self, rhs: i64) -> Self::Output
[src]
impl<'_> Add<f64> for &'_ Tensor
[src]
type Output = Tensor
The resulting type after applying the +
operator.
fn add(self, rhs: f64) -> Self::Output
[src]
impl Add<Tensor> for i64
[src]
type Output = Tensor
The resulting type after applying the +
operator.
fn add(self, rhs: Tensor) -> Self::Output
[src]
impl Add<Tensor> for f64
[src]
type Output = Tensor
The resulting type after applying the +
operator.
fn add(self, rhs: Tensor) -> Self::Output
[src]
impl<'_> Add<&'_ Tensor> for i64
[src]
type Output = Tensor
The resulting type after applying the +
operator.
fn add(self, rhs: &Tensor) -> Self::Output
[src]
impl<'_> Add<&'_ Tensor> for f64
[src]
type Output = Tensor
The resulting type after applying the +
operator.
fn add(self, rhs: &Tensor) -> Self::Output
[src]
impl Sub<Tensor> for Tensor
[src]
type Output = Tensor
The resulting type after applying the -
operator.
fn sub(self, rhs: Tensor) -> Self::Output
[src]
impl<'_> Sub<&'_ Tensor> for Tensor
[src]
type Output = Tensor
The resulting type after applying the -
operator.
fn sub(self, rhs: &Tensor) -> Self::Output
[src]
impl<'a, '_> Sub<&'_ Tensor> for &'a Tensor
[src]
type Output = Tensor
The resulting type after applying the -
operator.
fn sub(self, rhs: &Tensor) -> Self::Output
[src]
impl<'_> Sub<Tensor> for &'_ Tensor
[src]
type Output = Tensor
The resulting type after applying the -
operator.
fn sub(self, rhs: Tensor) -> Self::Output
[src]
impl Sub<i64> for Tensor
[src]
type Output = Tensor
The resulting type after applying the -
operator.
fn sub(self, rhs: i64) -> Self::Output
[src]
impl Sub<f64> for Tensor
[src]
type Output = Tensor
The resulting type after applying the -
operator.
fn sub(self, rhs: f64) -> Self::Output
[src]
impl<'_> Sub<i64> for &'_ Tensor
[src]
type Output = Tensor
The resulting type after applying the -
operator.
fn sub(self, rhs: i64) -> Self::Output
[src]
impl<'_> Sub<f64> for &'_ Tensor
[src]
type Output = Tensor
The resulting type after applying the -
operator.
fn sub(self, rhs: f64) -> Self::Output
[src]
impl Sub<Tensor> for i64
[src]
type Output = Tensor
The resulting type after applying the -
operator.
fn sub(self, rhs: Tensor) -> Self::Output
[src]
impl Sub<Tensor> for f64
[src]
type Output = Tensor
The resulting type after applying the -
operator.
fn sub(self, rhs: Tensor) -> Self::Output
[src]
impl<'_> Sub<&'_ Tensor> for i64
[src]
type Output = Tensor
The resulting type after applying the -
operator.
fn sub(self, rhs: &Tensor) -> Self::Output
[src]
impl<'_> Sub<&'_ Tensor> for f64
[src]
type Output = Tensor
The resulting type after applying the -
operator.
fn sub(self, rhs: &Tensor) -> Self::Output
[src]
impl Mul<Tensor> for Tensor
[src]
type Output = Tensor
The resulting type after applying the *
operator.
fn mul(self, rhs: Tensor) -> Self::Output
[src]
impl<'_> Mul<&'_ Tensor> for Tensor
[src]
type Output = Tensor
The resulting type after applying the *
operator.
fn mul(self, rhs: &Tensor) -> Self::Output
[src]
impl<'a, '_> Mul<&'_ Tensor> for &'a Tensor
[src]
type Output = Tensor
The resulting type after applying the *
operator.
fn mul(self, rhs: &Tensor) -> Self::Output
[src]
impl<'_> Mul<Tensor> for &'_ Tensor
[src]
type Output = Tensor
The resulting type after applying the *
operator.
fn mul(self, rhs: Tensor) -> Self::Output
[src]
impl Mul<i64> for Tensor
[src]
type Output = Tensor
The resulting type after applying the *
operator.
fn mul(self, rhs: i64) -> Self::Output
[src]
impl Mul<f64> for Tensor
[src]
type Output = Tensor
The resulting type after applying the *
operator.
fn mul(self, rhs: f64) -> Self::Output
[src]
impl<'_> Mul<i64> for &'_ Tensor
[src]
type Output = Tensor
The resulting type after applying the *
operator.
fn mul(self, rhs: i64) -> Self::Output
[src]
impl<'_> Mul<f64> for &'_ Tensor
[src]
type Output = Tensor
The resulting type after applying the *
operator.
fn mul(self, rhs: f64) -> Self::Output
[src]
impl Mul<Tensor> for i64
[src]
type Output = Tensor
The resulting type after applying the *
operator.
fn mul(self, rhs: Tensor) -> Self::Output
[src]
impl Mul<Tensor> for f64
[src]
type Output = Tensor
The resulting type after applying the *
operator.
fn mul(self, rhs: Tensor) -> Self::Output
[src]
impl<'_> Mul<&'_ Tensor> for i64
[src]
type Output = Tensor
The resulting type after applying the *
operator.
fn mul(self, rhs: &Tensor) -> Self::Output
[src]
impl<'_> Mul<&'_ Tensor> for f64
[src]
type Output = Tensor
The resulting type after applying the *
operator.
fn mul(self, rhs: &Tensor) -> Self::Output
[src]
impl Div<Tensor> for Tensor
[src]
type Output = Tensor
The resulting type after applying the /
operator.
fn div(self, rhs: Tensor) -> Self::Output
[src]
impl<'_> Div<&'_ Tensor> for Tensor
[src]
type Output = Tensor
The resulting type after applying the /
operator.
fn div(self, rhs: &Tensor) -> Self::Output
[src]
impl<'a, '_> Div<&'_ Tensor> for &'a Tensor
[src]
type Output = Tensor
The resulting type after applying the /
operator.
fn div(self, rhs: &Tensor) -> Self::Output
[src]
impl<'_> Div<Tensor> for &'_ Tensor
[src]
type Output = Tensor
The resulting type after applying the /
operator.
fn div(self, rhs: Tensor) -> Self::Output
[src]
impl Div<i64> for Tensor
[src]
type Output = Tensor
The resulting type after applying the /
operator.
fn div(self, rhs: i64) -> Self::Output
[src]
impl Div<f64> for Tensor
[src]
type Output = Tensor
The resulting type after applying the /
operator.
fn div(self, rhs: f64) -> Self::Output
[src]
impl<'_> Div<i64> for &'_ Tensor
[src]
type Output = Tensor
The resulting type after applying the /
operator.
fn div(self, rhs: i64) -> Self::Output
[src]
impl<'_> Div<f64> for &'_ Tensor
[src]
type Output = Tensor
The resulting type after applying the /
operator.
fn div(self, rhs: f64) -> Self::Output
[src]
impl Div<Tensor> for i64
[src]
type Output = Tensor
The resulting type after applying the /
operator.
fn div(self, rhs: Tensor) -> Self::Output
[src]
impl Div<Tensor> for f64
[src]
type Output = Tensor
The resulting type after applying the /
operator.
fn div(self, rhs: Tensor) -> Self::Output
[src]
impl<'_> Div<&'_ Tensor> for i64
[src]
type Output = Tensor
The resulting type after applying the /
operator.
fn div(self, rhs: &Tensor) -> Self::Output
[src]
impl<'_> Div<&'_ Tensor> for f64
[src]
type Output = Tensor
The resulting type after applying the /
operator.
fn div(self, rhs: &Tensor) -> Self::Output
[src]
impl Neg for Tensor
[src]
impl<'_> Neg for &'_ Tensor
[src]
impl AddAssign<Tensor> for Tensor
[src]
fn add_assign(&mut self, rhs: Tensor)
[src]
impl<'_> AddAssign<&'_ Tensor> for Tensor
[src]
fn add_assign(&mut self, rhs: &Tensor)
[src]
impl AddAssign<i64> for Tensor
[src]
fn add_assign(&mut self, rhs: i64)
[src]
impl AddAssign<f64> for Tensor
[src]
fn add_assign(&mut self, rhs: f64)
[src]
impl SubAssign<Tensor> for Tensor
[src]
fn sub_assign(&mut self, rhs: Tensor)
[src]
impl<'_> SubAssign<&'_ Tensor> for Tensor
[src]
fn sub_assign(&mut self, rhs: &Tensor)
[src]
impl SubAssign<i64> for Tensor
[src]
fn sub_assign(&mut self, rhs: i64)
[src]
impl SubAssign<f64> for Tensor
[src]
fn sub_assign(&mut self, rhs: f64)
[src]
impl MulAssign<Tensor> for Tensor
[src]
fn mul_assign(&mut self, rhs: Tensor)
[src]
impl<'_> MulAssign<&'_ Tensor> for Tensor
[src]
fn mul_assign(&mut self, rhs: &Tensor)
[src]
impl MulAssign<i64> for Tensor
[src]
fn mul_assign(&mut self, rhs: i64)
[src]
impl MulAssign<f64> for Tensor
[src]
fn mul_assign(&mut self, rhs: f64)
[src]
impl DivAssign<Tensor> for Tensor
[src]
fn div_assign(&mut self, rhs: Tensor)
[src]
impl<'_> DivAssign<&'_ Tensor> for Tensor
[src]
fn div_assign(&mut self, rhs: &Tensor)
[src]
impl DivAssign<i64> for Tensor
[src]
fn div_assign(&mut self, rhs: i64)
[src]
impl DivAssign<f64> for Tensor
[src]
fn div_assign(&mut self, rhs: f64)
[src]
impl Sum<Tensor> for Tensor
[src]
impl<'a> Sum<&'a Tensor> for Tensor
[src]
Auto Trait Implementations
Blanket Implementations
impl<T> From for T
[src]
impl<T, U> Into for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T> Borrow for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> BorrowMut for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T, U> TryInto for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,