Tensor Type
Represents a multi-dimensional data type containing elements of a single data type.
Example
A tensor can be constructed from a list or sequence using dfx.tensor
let t = dfx.tensor([[1.; -1.]; [1.; -1.]])
Instance members
| Instance member |
Description
|
|
|
|
|
|
Computes the element-wise absolute value of the given input tensor.
|
|
Returns a new tensor with the arccosine of the elements of input.
|
|
|
|
|
|
|
Full Usage:
this.allclose (tensor, ?relativeTolerance, ?absoluteTolerance)
Parameters:
Tensor
?relativeTolerance : float
?absoluteTolerance : float
Returns: bool
|
Indicates if two tensors have the same shape and all corresponding elements are equal within the given tolerances.
|
|
A debugging routine that returns the ancestors of a tensor involved in reverse-mode automatic differentiation
|
|
Returns the indexes of maximum values of the primal of the tensor, reducing the given dimension.
The resulting tensor does not participate in reverse or forward differentiation. It can be used as input to another operation such as
|
Full Usage:
this.argmax ()
Returns: int[]
|
Gets the index of a maximum value in the tensor.
|
|
Returns the indexes of minimum values of the primal of the tensor, reducing the given dimension.
The resulting tensor does not participate in reverse or forward differentiation. It can be used as input to another operation such as
|
Full Usage:
this.argmin ()
Returns: int[]
|
Gets the index of a minimum value in the tensor.
|
|
Returns a new tensor with the arcsine of the elements of input.
|
|
Returns a new tensor with the arctangent of the elements of input.
|
|
Gets the backend of the tensor
|
|
See
|
Full Usage:
this.bceLoss (target, ?weight, ?reduction)
Parameters:
Tensor
-
The target tensor.
?weight : Tensor
-
A manual rescaling weight given to the loss of each batch element.
?reduction : string
-
Optionally specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied, 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Note: size_average and reduce are in the process of being deprecated, and in the meantime, specifying either of those two args will override reduction. Default: 'mean'.
Returns: Tensor
|
Creates a criterion that measures the Binary Cross Entropy between the target and the output
|
Full Usage:
this.bernoulli (?device, ?dtype, ?backend)
Parameters:
Device
-
The desired device of returned tensor. Default: if None, uses Device.Default.
?dtype : Dtype
-
The desired element type of returned tensor. Default: if None, uses Dtype.Default.
?backend : Backend
-
The desired backend of returned tensor. Default: if None, uses Backend.Default.
Returns: Tensor
|
Draws binary random numbers (0 or 1) from a Bernoulli distribution
|
|
Returns a new tensor with each element converted to type bfloat16
|
|
Returns a new tensor with each element converted to type bool
|
|
Returns a new tensor with each element converted to type float64
|
|
Converts the tensor to a new tensor with the given system type
|
|
|
|
Returns a new tensor with the ceil of the elements of input, the smallest integer greater than or equal to each element. The tensor will have the same element type as the input tensor.
|
|
|
|
Returns a new tensor with underlying storage copied. This method discards differentiability and returns a constant tensor.
|
|
|
Full Usage:
this.conv2d (filters, ?stride, ?padding, ?dilation, ?strides, ?paddings, ?dilations)
Parameters:
Tensor
-
The filters.
?stride : int
-
The stride of the convolving kernel.
?padding : int
-
The implicit padding on corresponding sides of the input.
?dilation : int
-
The spacing between kernel elements.
?strides : int seq
-
The strides of the convolving kernel.
?paddings : int seq
-
The implicit paddings on corresponding sides of the input.
?dilations : int seq
-
The spacings between kernel elements.
Returns: Tensor
|
Applies a 2D convolution over an input signal composed of several input planes
|
Full Usage:
this.conv3d (filters, ?stride, ?padding, ?dilation, ?strides, ?paddings, ?dilations)
Parameters:
Tensor
-
The filters.
?stride : int
-
The stride of the convolving kernel.
?padding : int
-
The implicit padding on corresponding sides of the input.
?dilation : int
-
The spacing between kernel elements.
?strides : int seq
-
The strides of the convolving kernel.
?paddings : int seq
-
The implicit paddings on corresponding sides of the input.
?dilations : int seq
-
The spacings between kernel elements.
Returns: Tensor
|
Applies a 3D convolution over an input signal composed of several input planes
|
Full Usage:
this.convTranspose1d (filters, ?stride, ?padding, ?dilation, ?outputPadding)
Parameters:
Tensor
-
The filters.
?stride : int
-
The stride of the convolving kernel.
?padding : int
-
The implicit padding on both sides of the input.
?dilation : int
-
The spacing between kernel elements.
?outputPadding : int
-
The additional size added to one side of each dimension in the output shape.
Returns: Tensor
|
Applies a 1D transposed convolution operator over an input signal composed of several input planes, sometimes also called 'deconvolution'.
|
Full Usage:
this.convTranspose2d (filters, ?stride, ?padding, ?dilation, ?outputPadding, ?strides, ?paddings, ?dilations, ?outputPaddings)
Parameters:
Tensor
-
The filters.
?stride : int
-
The stride of the convolving kernel.
?padding : int
-
The implicit padding on both sides of the input.
?dilation : int
-
The spacing between kernel elements.
?outputPadding : int
-
The additional size added to one side of each dimension in the output shape.
?strides : int seq
-
The strides of the convolving kernel.
?paddings : int seq
-
The implicit paddings on corresponding sides of the input.
?dilations : int seq
-
The spacings between kernel elements.
?outputPaddings : int seq
-
The additional sizes added to one side of each dimension in the output shape.
Returns: Tensor
|
Applies a 2D transposed convolution operator over an input signal composed of several input planes, sometimes also called 'deconvolution'.
|
Full Usage:
this.convTranspose3d (filters, ?stride, ?padding, ?dilation, ?outputPadding, ?strides, ?paddings, ?dilations, ?outputPaddings)
Parameters:
Tensor
-
The filters.
?stride : int
-
The stride of the convolving kernel.
?padding : int
-
The implicit padding on both sides of the input.
?dilation : int
-
The spacing between kernel elements.
?outputPadding : int
-
The additional size added to one side of each dimension in the output shape.
?strides : int seq
-
The strides of the convolving kernel.
?paddings : int seq
-
The implicit paddings on corresponding sides of the input.
?dilations : int seq
-
The spacings between kernel elements.
?outputPaddings : int seq
-
The additional sizes added to one side of each dimension in the output shape.
Returns: Tensor
|
Applies a 3D transposed convolution operator over an input signal composed of several input planes, sometimes also called 'deconvolution'.
|
Full Usage:
this.corrcoef ()
Returns: Tensor
The correlation coefficient matrix \(R\) is computed from the covariance
matrix
Returns a square tensor representing the correlation coefficient matrix.
Given a tensor with \(N\) variables \(X=[x_1,x_2,\ldots,x_N]\) the
\(R_{i,j}\) entry on the correlation matrix is the correlation between
\(x_i\) and \(x_j\).
|
Estimates the Pearson correlation coefficient matrix for the given tensor. The tensor's first dimension should index variables and the second dimension should index observations for each variable. The correlation between variables \(x\) and \(y\) is \[cor(x,y)= \frac{\sum^{N}_{i = 1}(x_{i} - \mu_x)(y_{i} - \mu_y)}{\sigma_x \sigma_y (N ~-~1)}\] where \(\mu_x\) and \(\mu_y\) are the sample means and \(\sigma_x\) and \(\sigma_x\) are the sample standard deviations.
Example
val x: obj
val y: obj
val xy: obj
Evaluates to
|
|
Returns a new tensor with the cosine of the elements of input
|
|
Returns a new tensor with the hyperbolic cosine of the elements of input.
|
Full Usage:
this.cov (?correction, ?fweights, ?aweights)
Parameters:
int64
-
Difference between the sample size and the sample degrees of freedom. Defaults to 1 (Bessel's correction).
?fweights : Tensor
-
Frequency weights represent the number of times each observation was observed.
Should be given as a tensor of integers. Defaults to no weights.
?aweights : Tensor
-
Relative importance weights, larger weights for observations that
should have a larger effect on the estimate.
Should be given as a tensor of floating point numbers. Defaults to no weights.
Returns: Tensor
Returns a square tensor representing the covariance matrix.
Given a tensor with \(N\) variables \(X=[x_1,x_2,\ldots,x_N]\) the
\(C_{i,j}\) entry on the covariance matrix is the covariance between
\(x_i\) and \(x_j\).
|
Estimates the covariance matrix of the given tensor. The tensor's first dimension should index variables and the second dimension should index observations for each variable.
If no weights are given, the covariance between variables \(x\) and \(y\) is
\[cov(x,y)= \frac{\sum^{N}_{i = 1}(x_{i} - \mu_x)(y_{i} - \mu_y)}{N~-~\text{correction}}\]
where \(\mu_x\) and \(\mu_y\) are the sample means.
If there are fweights or aweights then the covariance is
\[cov(x,y)=\frac{\sum^{N}_{i = 1}w_i(x_{i} - \mu_x^*)(y_{i} - \mu_y^*)}{\text{normalization factor}}\]
where \(w\) is either fweights or aweights if one weight type is provided.
If both weight types are provided \(w=\text{fweights}\times\text{aweights}\).
\(\mu_x^* = \frac{\sum^{N}_{i = 1}w_ix_{i} }{\sum^{N}_{i = 1}w_i}\)
is the weighted mean of variables.
The normalization factor is \(\sum^{N}_{i=1} w_i\) if only fweights are provided or if aweights are provided and
Example
val x: obj
val y: obj
val xy: obj
Evaluates to
|
|
Returns a new tensor with the same contents moved to the CPU
|
Full Usage:
this.crossEntropyLoss (target, ?weight, ?reduction)
Parameters:
Tensor
-
The target tensor.
?weight : Tensor
-
A optional manual rescaling weight given to the loss of each batch element.
?reduction : string
-
Optionally specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied, 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Note: size_average and reduce are in the process of being deprecated, and in the meantime, specifying either of those two args will override reduction. Default: 'mean'.
Returns: Tensor
|
This criterion combines logsoftmax and nllLoss in a single function
|
Full Usage:
this.depth
Returns: int
|
Gets the differentiation depth of the tensor
|
|
Gets or sets the derivative of a tensor used in differentiation
|
|
|
|
Gets the device of the tensor
|
|
Gets the device type of the tensor
|
Full Usage:
this.diagonal (?offset, ?dim1, ?dim2)
Parameters:
int
?dim1 : int
?dim2 : int
Returns: Tensor
|
Returns a tensor with the diagonal elements with respect to
|
Full Usage:
this.dilate dilations
Parameters:
int seq
-
The dilations to use.
Returns: Tensor
|
Dilate the tensor in using the given dilations in each corresponding dimension.
|
Full Usage:
this.dim
Returns: int
|
Gets the number of dimensions of the tensor
|
|
|
|
|
|
|
|
Returns a new tensor with each element converted to type float64
|
Full Usage:
this.dropout ?p
Parameters:
double
-
The probability of an element to be zeroed. Default: 0.5.
Returns: Tensor
|
Randomly zeroes some of the elements of the input tensor with probability p using samples from a Bernoulli distribution
|
Full Usage:
this.dropout2d ?p
Parameters:
double
-
The probability of an element to be zeroed. Default: 0.5.
Returns: Tensor
|
Randomly zero out entire channels (a channel is a 2D feature map, e.g., the jj -th channel of the ii -th sample in the batched input is a 2D tensor \text{input}[i, j]input[i,j] ). Each channel will be zeroed out independently on every forward call with probability p using samples from a Bernoulli distribution
|
Full Usage:
this.dropout3d ?p
Parameters:
double
-
The probability of an element to be zeroed. Default: 0.5.
Returns: Tensor
|
Randomly zero out entire channels (a channel is a 3D feature map, e.g., the jj -th channel of the ii -th sample in the batched input is a 3D tensor \text{input}[i, j]input[i,j] ). Each channel will be zeroed out independently on every forward call with probability p using samples from a Bernoulli distribution.
|
|
Gets the element type of the tensor
|
Full Usage:
this.elementSize
Returns: int
|
Returns the size in bytes of an individual element in this tensor. Depending on dtype, backend configuration, this is not guaranteed to be correct and can behave differently in different runtime environments.
|
|
Applies the exp function element-wise.
|
|
Returns a new view of the object tensor with singleton dimensions expanded to a larger size.
Passing -1 as the size for a dimension means not changing the size of that dimension. The tensor can be also expanded to a larger number of dimensions, and the new ones will be appended at the front. For the new dimensions, the size cannot be set to -1. Expanding a tensor does not allocate new memory, but only creates a new view on the existing tensor where a dimension of size one is expanded to a larger size by setting the stride to 0. Any dimension of size 1 can be expanded to an arbitrary value without allocating new memory.
|
|
|
Full Usage:
this.fanout
Returns: uint32
|
Gets the fanout of a tensor used in reverse-mode differentiation
|
Full Usage:
this.flatten (?startDim, ?endDim)
Parameters:
int
-
The first dim to flatten.
?endDim : int
-
The last dim to flatten.
Returns: Tensor
|
Flattens a contiguous range of dims in a tensor.
|
|
Reverse the order of a n-D tensor along given axis in dims
|
|
Returns a new tensor with each element converted to type float64
|
|
Returns a new tensor with each element converted to type float16
|
|
Returns a new tensor with each element converted to type float32
|
|
Returns a new tensor with each element converted to type float64
|
|
Returns a new tensor with the floor of the elements of input, the largest integer less than or equal to each element. The tensor will have the same element type as the input tensor.
|
|
Returns the input tensor with added support for forward-mode automatic differentiation. Any tensors produced using this tensor will have attached derivatives for forward mode propagation. The current global nesting level is used for nested differentiation.
|
|
|
|
Returns a new tensor with the same contents moved to the primary GPU device
|
Full Usage:
this.hasinf ()
Returns: bool
|
Gets if any value in the tensor is +/- INF.
|
Full Usage:
this.hasinfnan ()
Returns: bool
|
Gets if any value in the tensor is NaN or +/- INF.
|
Full Usage:
this.hasnan ()
Returns: bool
|
Gets if any value in the tensor is NaN.
|
|
Returns a new tensor with each element converted to type int32
|
|
Returns a new tensor with each element converted to type int16
|
|
Returns a new tensor with each element converted to type int32
|
|
Returns a new tensor with each element converted to type int64
|
|
Returns a new tensor with each element converted to type int8
|
Full Usage:
this.isForwardDiff
Returns: bool
|
Indicates if a tensor is taking part in forward-mode differentiation
|
Full Usage:
this.isNoDiff
Returns: bool
|
Indicates if a tensor is a constant, meaning that it is not taking part in forward or reverse-mode differentiation
|
Full Usage:
this.isReverseDiff
Returns: bool
|
Indicates if a tensor is taking part in reverse-mode differentiation
|
|
|
|
Returns a new tensor with boolean elements representing if each element is +/-INF or not.
|
|
Returns a new tensor with boolean elements representing if each element is NaN or not. Complex values are considered NaN when either their real and/or imaginary part is NaN.
|
Full Usage:
this.leakyRelu ?negativeSlope
Parameters:
float
-
Controls the angle of the negative slope. Default: 0.01.
Returns: Tensor
|
Applies the leaky rectified linear unit function element-wise \[\text{leakyRelu}(x) = \max(0, x) + \text{negativeSlope} * \min(0, x)\]
|
|
|
|
Returns a new tensor with the natural logarithm of the elements of input. \[y_{i} = \log_{e} (x_{i})\]
|
|
Returns a new tensor with the logarithm to the base 10 of the elements of input. \[y_{i} = \log_{10} (x_{i})\]
|
Full Usage:
this.logsoftmax dim
Parameters:
int
-
A dimension along which softmax will be computed.
Returns: Tensor
|
Applies a softmax followed by a logarithm.
|
Full Usage:
this.logsumexp (dim, ?keepDim)
Parameters:
int
-
The dimension to reduce.
?keepDim : bool
-
Whether the output tensor has dim retained or not.
Returns: Tensor
|
Applies a logsumexp.
|
|
Matrix product of two tensors.
The behavior depends on the dimensionality of the tensors as follows: If both tensors are 1-dimensional, the dot product (scalar) is returned. If both arguments are 2-dimensional, the matrix-matrix product is returned. If the first argument is 1-dimensional and the second argument is 2-dimensional, a 1 is prepended to its dimension for the purpose of the matrix multiply. After the matrix multiply, the prepended dimension is removed. If the first argument is 2-dimensional and the second argument is 1-dimensional, the matrix-vector product is returned. If both arguments are at least 1-dimensional and at least one argument is N-dimensional (where N > 2), then a batched matrix multiply is returned. If the first argument is 1-dimensional, a 1 is prepended to its dimension for the purpose of the batched matrix multiply and removed after. If the second argument is 1-dimensional, a 1 is appended to its dimension for the purpose of the batched matrix multiple and removed after. The non-matrix (i.e. batch) dimensions are broadcasted (and thus must be broadcastable). For example, if input is a (j \times 1 \times n \times m)(j×1×n×m) tensor and other is a (k \times m \times p)(k×m×p) tensor, out will be an (j \times k \times n \times p)(j×k×n×p) tensor.
|
|
|
|
Returns the maximum value of all elements in the input tensor.
|
|
Returns the maximum value along the given dimension of all elements in the input tensor.
|
Full Usage:
this.maxpool1d (kernelSize, ?stride, ?padding)
Parameters:
int
-
The size of the window to take a max over.
?stride : int
-
The stride of the window. Default value is kernelSize.
?padding : int
-
The implicit zero padding to be added on both sides.
Returns: Tensor
|
Applies a 1D max pooling over an input signal composed of several input planes.
|
|
Applies a 1D max pooling over an input signal composed of several input planes, returning the max indices along with the outputs.
|
Full Usage:
this.maxpool2d (?kernelSize, ?stride, ?padding, ?kernelSizes, ?strides, ?paddings)
Parameters:
int
-
The size of the window to take a max over.
?stride : int
-
The stride of the window. Default value is kernelSize.
?padding : int
-
The implicit zero padding to be added on both sides.
?kernelSizes : int seq
-
The sizes of the window to take a max over.
?strides : int seq
-
The strides of the window. Default value is kernelSize.
?paddings : int seq
-
The implicit zero paddings to be added on corresponding sides.
Returns: Tensor
|
Applies a 2D max pooling over an input signal composed of several input planes.
|
Full Usage:
this.maxpool2di (?kernelSize, ?stride, ?padding, ?kernelSizes, ?strides, ?paddings)
Parameters:
int
-
The size of the window to take a max over.
?stride : int
-
The stride of the window. Default value is kernelSize.
?padding : int
-
The implicit zero padding to be added on both sides.
?kernelSizes : int seq
-
The sizes of the window to take a max over.
?strides : int seq
-
The strides of the window. Default value is kernelSize.
?paddings : int seq
-
The implicit zero paddings to be added on corresponding sides.
Returns: Tensor * Tensor
|
Applies a 2D max pooling over an input signal composed of several input planes, returning the max indices along with the outputs.
|
Full Usage:
this.maxpool3d (?kernelSize, ?stride, ?padding, ?kernelSizes, ?strides, ?paddings)
Parameters:
int
-
The size of the window to take a max over.
?stride : int
-
The stride of the window. Default value is kernelSize.
?padding : int
-
The implicit zero padding to be added on both sides.
?kernelSizes : int seq
-
The sizes of the window to take a max over.
?strides : int seq
-
The strides of the window. Default value is kernelSizes.
?paddings : int seq
-
The implicit zero paddings to be added on corresponding sides.
Returns: Tensor
|
Applies a 3D max pooling over an input signal composed of several input planes.
|
Full Usage:
this.maxpool3di (?kernelSize, ?stride, ?padding, ?kernelSizes, ?strides, ?paddings)
Parameters:
int
-
The size of the window to take a max over.
?stride : int
-
The stride of the window. Default value is kernelSize.
?padding : int
-
The implicit zero padding to be added on both sides.
?kernelSizes : int seq
-
The sizes of the window to take a max over.
?strides : int seq
-
The strides of the window. Default value is kernelSize.
?paddings : int seq
-
The implicit zero paddings to be added on corresponding sides.
Returns: Tensor * Tensor
|
Applies a 3D max pooling over an input signal composed of several input planes, returning the max indices along with the outputs.
|
Full Usage:
this.maxunpool1d (indices, kernelSize, ?stride, ?padding, ?outputSize)
Parameters:
Tensor
-
The indices selected by maxpool1di.
kernelSize : int
-
The size of the window to take a max over.
?stride : int
-
The stride of the window. Default value is kernelSize.
?padding : int
-
The implicit zero padding to be added on both sides.
?outputSize : int seq
-
The targeted output size.
Returns: Tensor
|
Computes a partial inverse of maxpool1di
|
Full Usage:
this.maxunpool2d (indices, ?kernelSize, ?stride, ?padding, ?kernelSizes, ?strides, ?paddings, ?outputSize)
Parameters:
Tensor
-
The indices selected by maxpool2di.
?kernelSize : int
-
The size of the window to take a max over.
?stride : int
-
The stride of the window. Default value is kernelSize.
?padding : int
-
The implicit zero padding to be added on both sides.
?kernelSizes : int seq
-
The sizes of the window to take a max over.
?strides : int seq
-
The strides of the window. Default value is kernelSizes.
?paddings : int seq
-
The implicit zero paddings to be added on corresponding sides.
?outputSize : int seq
-
The targeted output size.
Returns: Tensor
|
Computes a partial inverse of maxpool2di
|
Full Usage:
this.maxunpool3d (indices, ?kernelSize, ?stride, ?padding, ?kernelSizes, ?strides, ?paddings, ?outputSize)
Parameters:
Tensor
-
The indices selected by maxpool3di.
?kernelSize : int
-
The size of the window to take a max over.
?stride : int
-
The stride of the window. Default value is kernelSize.
?padding : int
-
The implicit zero padding to be added on both sides.
?kernelSizes : int seq
-
The sizes of the window to take a max over.
?strides : int seq
-
The strides of the window. Default value is kernelSizes.
?paddings : int seq
-
The implicit zero paddings to be added on corresponding sides.
?outputSize : int seq
-
The targeted output size.
Returns: Tensor
|
Computes a partial inverse of maxpool3di
|
Full Usage:
this.mean (dim, ?keepDim)
Parameters:
int
-
The dimension to reduce.
?keepDim : bool
-
Whether the output tensor has dim retained or not.
Returns: Tensor
|
Returns the mean value of each row of the input tensor in the given dimension dim. If keepdim is True, the output tensor is of the same size as input except in the dimension dim where it is of size 1. Otherwise, dim is squeezed, resulting in the output tensor having 1 fewer dimension.
|
|
Returns the mean value of all elements in the input tensor
|
Full Usage:
this.memorySize
Returns: int64
|
Returns the size in bytes of the total memory used by this tensor. Depending on dtype, backend configuration, this is not guaranteed to be correct and can behave differently in different runtime environments.
|
|
|
|
Returns the minimum value of all elements in the input tensor.
|
|
Returns the minimum value along the given dimension of all elements in the input tensor.
|
|
|
|
|
|
|
Full Usage:
this.mseLoss (target, ?reduction)
Parameters:
Tensor
-
The target tensor.
?reduction : string
-
Optionally specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied, 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Note: size_average and reduce are in the process of being deprecated, and in the meantime, specifying either of those two args will override reduction. Default: 'mean'.
Returns: Tensor
|
Creates a criterion that measures the mean squared error (squared L2 norm) between each element in the input and the target.
|
|
|
|
|
Full Usage:
this.multinomial (numSamples, ?normalize, ?device, ?dtype, ?backend)
Parameters:
int
-
The number of samples to draw.
?normalize : bool
-
Indicates where the probabilities should first be normalized by their sum.
?device : Device
-
The desired device of returned tensor. Default: if None, uses Device.Default.
?dtype : Dtype
-
The desired element type of returned tensor. Default: if None, uses Dtype.Default.
?backend : Backend
-
The desired backend of returned tensor. Default: if None, uses Backend.Default.
Returns: Tensor
|
Returns a tensor where each row contains numSamples indices sampled from the multinomial probability distribution located in the corresponding row of tensor input.
|
|
Returns a new tensor with the negative of the elements of the object tensor.
|
Full Usage:
this.nelement
Returns: int
|
Gets the number of elements in the tensor
|
Full Usage:
this.nestingTag
Returns: uint32
|
Gets the differentiation nesting tag of the tensor
|
Full Usage:
this.nllLoss (target, ?weight, ?reduction)
Parameters:
Tensor
-
The target tensor.
?weight : Tensor
-
A optional manual rescaling weight given to the loss of each batch element.
?reduction : string
-
Optionally specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied, 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Note: size_average and reduce are in the process of being deprecated, and in the meantime, specifying either of those two args will override reduction. Default: 'mean'.
Returns: Tensor
|
The negative log likelihood loss.
|
|
Returns the input tensor but with any support for automatic differentiation removed.
|
|
Returns the tensor after min-max scaling
|
|
|
|
|
|
|
Full Usage:
this.pad paddings
Parameters:
int seq
-
The implicit paddings on corresponding sides of the input.
Returns: Tensor
|
Add zero padding to each side of a tensor
|
|
Gets the parent operation of a tensor used in reverse-mode differentiation
|
Full Usage:
this.permute permutation
Parameters:
int seq
-
The desired ordering of dimensions.
Returns: Tensor
|
Returns the original tensor with its dimensions permuted.
|
|
|
|
|
|
Gets the value of the tensor ignoring its first derivative
|
|
Gets the value of the tensor ignoring all its derivatives
|
|
Gets the raw value of the tensor ignoring all its derivatives
|
|
|
|
|
|
Applies the rectified linear unit function element-wise.
|
Full Usage:
this.repeat (dim, times)
Parameters:
int
-
The dimension along which to repeat values.
times : int
-
The number of repetitions for each element.
Returns: Tensor
|
Repeat elements of a tensor
|
Full Usage:
this.reverse (?value, ?zeroDerivatives)
Parameters:
Tensor
-
The derivative value to propagate backwards. Should have the same shape with this tensor.
?zeroDerivatives : bool
-
Indicates whether any existing derivatives in the computation graph (for example from a previous reverse propagation that was executed) should be zeroed or not before starting this propagation. Default: true
|
Propagate the reverse-mode derivative backwards in the computation graph, starting from this tensor.
|
Full Usage:
this.reverseDiff (?derivative, ?nestingTag)
Parameters:
Tensor
-
The derivative (adjoint) to assign to the new reverse-mode tensor. Defaults to an empty placeholder tensor.
?nestingTag : uint32
-
The level nestingTag for nested differentiation. Defaults to the current global nesting level
Returns: Tensor
|
Returns the input tensor with added support for reverse-mode automatic differentiation.
Any tensors produced using this tensor will also support reverse-mode propagation. After the completion
of the corresponding
|
|
Push the given value as part of the reverse-mode computation at the given output tensor.
|
Full Usage:
this.reverseReset zeroDerivatives
Parameters:
bool
|
Reset the reverse mode computation graph associated with the given output tensor.
|
|
Returns a new tensor with each of the elements of input rounded to the closest integer. The tensor will have the same element type as the input tensor.
|
|
Returns the logarithm of the tensor after clamping the tensor so that all its elements are greater than epsilon. This is to avoid a -inf result for elements equal to zero.
|
Full Usage:
this.save fileName
Parameters:
string
|
Saves the tensor to the given file using a bespoke binary format. The binary format records the elements, backend, element type and shape. It does not record the device. The format used may change from version to version of Dfx.
|
|
|
|
Gets the shape of the tensor
|
|
Applies the sigmoid element-wise function \[\text{sigmoid}(x) = \frac{1}{1 + \exp(-x)}\]
|
|
Returns a new tensor with the signs of the elements of input. The tensor will have the same element type as the input tensor.
|
|
Returns a new tensor with the sine of the elements of input
|
|
Returns a new tensor with the hyperbolic sine of the elements of input.
|
Full Usage:
this.softmax dim
Parameters:
int
-
A dimension along which softmax will be computed.
Returns: Tensor
|
Applies a softmax function. Softmax is defined as: \text{softmax}(x_{i}) = \frac{\exp(x_i)}{\sum_j \exp(x_j)}.
|
|
Applies the softplus function element-wise. \[\text{softplus}(x) = \frac{1}{\beta} * \log(1 + \exp(\beta * x))\]
|
Full Usage:
this.split (sizes, ?dim)
Parameters:
int seq
-
List of sizes for each chunk
?dim : int
-
The dimension along which to split the tensor, defaults to 0.
Returns: Tensor array
|
Splits the tensor into chunks. Each chunk is a view of the original tensor.
|
|
Returns a new tensor with the square-root of the elements of input.
|
Full Usage:
this.squeeze ?dim
Parameters:
int
-
If given, the input will be squeezed only in this dimension.
Returns: Tensor
|
Returns a tensor with all the dimensions of input of size 1 removed. If the tensor has a batch dimension of size 1, then squeeze(input) will also remove the batch dimension, which can lead to unexpected errors.
|
|
Returns the tensor after standardization (z-score normalization)
|
Full Usage:
this.std ?unbiased
Parameters:
bool
-
Whether to use the unbiased estimation or not.
Returns: Tensor
|
Returns the standard deviation of all elements in the input tensor. If unbiased is False, then the standard deviation will be calculated via the biased estimator. Otherwise, Bessel’s correction will be used.
|
Full Usage:
this.std (dim, ?keepDim, ?unbiased)
Parameters:
int
-
The dimension to reduce.
?keepDim : bool
-
Whether the output tensor has dim retained or not.
?unbiased : bool
-
Whether to use the unbiased estimation or not.
Returns: Tensor
|
Returns the standard deviation of each row of the input tensor in the given dimension dim.
If keepdim is True, the output tensor is of the same size as input except in the dimension dim where it is of size 1. Otherwise, dim is squeezed, resulting in the output tensor having 1 fewer dimension(s). If unbiased is False, then the standard deviation will be calculated via the biased estimator. Otherwise, Bessel’s correction will be used.
|
|
|
|
|
|
Returns the sum of each row of the input tensor in the given dimension dim. If dim is a list of dimensions, reduce over all of them.
If keepdim is
|
|
|
|
|
Full Usage:
this.summary ()
Returns: string
|
Returns a string summarising the tensor
|
|
Returns a new tensor with the tangent of the elements of input
|
|
Returns a new tensor with the hyperbolic tangent of the elements of input.
|
|
Returns the value of a (non-scalar) tensor as an array
|
Full Usage:
this.toArray1D ()
Returns: 'T[]
Type parameters: 'T |
Returns the value of a 1D tensor as a 1D array
|
Full Usage:
this.toArray2D ()
Returns: 'T[,]
Type parameters: 'T |
Returns the value of a 2D tensor as a 2D array
|
Full Usage:
this.toArray3D ()
Returns: 'T[,,]
Type parameters: 'T |
Returns the value of a 3D tensor as a 3D array
|
Full Usage:
this.toArray4D ()
Returns: 'T[,,,]
Type parameters: 'T |
Returns the value of a 4D tensor as a 4D array
|
|
Returns the value of a 5D tensor as a 5D array
|
|
Returns the value of a 6D tensor as a 6D array
|
Full Usage:
this.toBool ()
Returns: bool
|
Convert a scalar tensor to a boolean value
|
Full Usage:
this.toByte ()
Returns: byte
|
Convert a scalar tensor to a byte value
|
Full Usage:
this.toDouble ()
Returns: float
|
Convert a scalar tensor to a float64 value
|
Full Usage:
this.toImage (?pixelMin, ?pixelMax, ?normalize, ?gridCols)
Parameters:
double
?pixelMax : double
?normalize : bool
?gridCols : int
Returns: Tensor
|
Convert tensor to an image tensor with shape Channels x Height x Width
|
Full Usage:
this.toImageString (?pixelMin, ?pixelMax, ?normalize, ?gridCols, ?asciiPalette)
Parameters:
double
?pixelMax : double
?normalize : bool
?gridCols : int
?asciiPalette : string
Returns: string
|
Convert tensor to a grayscale image tensor and return a string representation approximating grayscale values
|
Full Usage:
this.toInt16 ()
Returns: int16
|
Convert a scalar tensor to an int16 value
|
Full Usage:
this.toInt32 ()
Returns: int
|
Convert a scalar tensor to an int32 value
|
Full Usage:
this.toInt64 ()
Returns: int64
|
Convert a scalar tensor to an int64 value
|
Full Usage:
this.toSByte ()
Returns: sbyte
|
Convert a scalar tensor to a signed byte value
|
|
Returns the value of a scalar tensor as an object
|
Full Usage:
this.toSingle ()
Returns: float32
|
Convert a scalar tensor to a float32 value
|
|
Returns the sum of the elements of the diagonal of the input 2-D matrix.
|
|
Returns a tensor that is a transposed version of input with dimensions 0 and 1 swapped.
|
Full Usage:
this.transpose (dim0, dim1)
Parameters:
int
-
The first dimension to be transposed.
dim1 : int
-
The second dimension to be transposed.
Returns: Tensor
|
Returns a tensor that is a transposed version of input. The given dimensions dim0 and dim1 are swapped.
|
Full Usage:
this.undilate dilations
Parameters:
int seq
-
The dilations to use.
Returns: Tensor
|
Reverse the dilation of the tensor in using the given dilations in each corresponding dimension.
|
Full Usage:
this.unflatten (dim, unflattenedShape)
Parameters:
int
-
The dimension to unflatten.
unflattenedShape : int seq
-
New shape of the unflattened dimenension.
Returns: Tensor
|
Unflattens a tensor dimension by expanding it to the given shape.
|
Full Usage:
this.unsqueeze dim
Parameters:
int
-
The index at which to insert the singleton dimension.
Returns: Tensor
|
Returns a new tensor with a dimension of size one inserted at the specified position
|
|
|
Full Usage:
this.unstack ?dim
Parameters:
int
-
The dimension to remove, defaults to 0.
Returns: Tensor array
Returns an array of all slices along a given dimension.
|
Removes a tensor dimension.
|
Full Usage:
this.var (dim, ?keepDim, ?unbiased)
Parameters:
int
-
The dimension to reduce.
?keepDim : bool
-
Whether the output tensor has dim retained or not.
?unbiased : bool
-
Whether to use the unbiased estimation or not.
Returns: Tensor
|
Returns the variance of each row of the input tensor in the given dimension dim.
If keepdim is True, the output tensor is of the same size as input except in the dimension dim where it is of size 1. Otherwise, dim is squeezed, resulting in the output tensor having 1 fewer dimension(s). If unbiased is False, then the variance will be calculated via the biased estimator. Otherwise, Bessel’s correction will be used.
|
Full Usage:
this.var ?unbiased
Parameters:
bool
-
Whether to use the unbiased estimation or not.
Returns: Tensor
|
Returns the variance of all elements in the input tensor. If unbiased is False, then the variance will be calculated via the biased estimator. Otherwise, Bessel’s correction will be used.
|
|
Returns a new tensor with the same data as the object tensor but of a different shape. The returned tensor shares the same data and must have the same number of elements, but may have a different size. For a tensor to be viewed, the new view size must be compatible with its original size and stride, i.e., each new view dimension must either be a subspace of an original dimension, or only span across original dimensions \(d, d+1, \dots, d+kd,d+1,…,d+k\) that satisfy the following contiguity-like condition that \(\forall i = d, \dots, d+k-1∀i=d,…,d+k−1 ,\) \[\text{stride}[i] = \text{stride}[i+1] \times \text{size}[i+1]\]
|
Full Usage:
this.view shape
Parameters:
int seq
-
The desired shape of returned tensor.
Returns: Tensor
|
Returns a new tensor with the same data as the self tensor but of a different shape. The returned tensor shares the same data and must have the same number of elements, but may have a different size. For a tensor to be viewed, the new view size must be compatible with its original size and stride, i.e., each new view dimension must either be a subspace of an original dimension, or only span across original dimensions \(d, d+1, \dots, d+kd,d+1,…,d+k\) that satisfy the following contiguity-like condition that \(\forall i = d, \dots, d+k-1∀i=d,…,d+k−1 ,\) \[\text{stride}[i] = \text{stride}[i+1] \times \text{size}[i+1]\]
|
|
View this tensor as the same size as other. The returned tensor shares the same data and must have the same number of elements, but may have a different size. For a tensor to be viewed, the new view size must be compatible with its original size. The returned tensor shares the same data and must have the same number of elements, but may have a different size. For a tensor to be viewed, the new view size must be compatible with its original size and stride, i.e., each new view dimension must either be a subspace of an original dimension, or only span across original dimensions \(d, d+1, \dots, d+kd,d+1,…,d+k\) that satisfy the following contiguity-like condition that \(\forall i = d, \dots, d+k-1∀i=d,…,d+k−1 ,\) \[\text{stride}[i] = \text{stride}[i+1] \times \text{size}[i+1]\]
|
|
|
|
Static members
| Static member |
Description
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Get the scalar one tensor for the current configuration
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Get the scalar zero tensor for the current configuration
|
|
Concatenates the given sequence of seq tensors in the given dimension. All tensors must either have the same shape (except in the concatenating dimension) or be empty.
|
Full Usage:
Tensor.create (value, ?device, ?dtype, ?backend)
Parameters:
obj
-
The .NET object used to form the initial values for the tensor.
?device : Device
-
The desired device of returned tensor. Default: if None, uses Device.Default.
?dtype : Dtype
-
The desired element type of returned tensor. Default: if None, uses Dtype.Default.
?backend : Backend
-
The desired backend of returned tensor. Default: if None, uses Backend.Default.
Returns: Tensor
|
Creates a new tensor from the given data, using the given element type and configuration. The fastest creation technique is a one dimensional array matching the desired dtype. Then use 'view' to reshape.
|
|
|
Full Usage:
Tensor.load (fileName, ?device, ?dtype, ?backend)
Parameters:
string
-
The file from which to load the tensor.
?device : Device
-
The device of the resulting tensor. Defaults to the current default device.
?dtype : Dtype
-
The element type of the resulting tensor. Defaults to the element type of the saved tensor.
?backend : Backend
-
The device of the resulting tensor. Defaults to the current default backend.
Returns: Tensor
|
Loads the tensor from the given file using the given element type and configuration. The backend at the time of saving the tensor must be available when the tensor is reloaded. The tensor is first loaded into that backend and then moved. As a result, intermediate tensors may be created in the process of reloading.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
© Copyright 2021, DiffSharp and dfx Contributors.