def unique(input, sorted=False, return_inverse=False, dim=None):
r"""Returns the unique scalar elements of the input tensor as a 1-D tensor.
Arguments:
input (Tensor): the input tensor
sorted (bool): Whether to sort the unique elements in ascending order
before returning as output.
return_inverse (bool): Whether to also return the indices for where
elements in the original input ended up in the returned unique list.
Returns:
(Tensor, Tensor (optional)): A tensor or a tuple of tensors containing
- **output** (*Tensor*): the output list of unique scalar elements.
- **inverse_indices** (*Tensor*): (optional) if
:attr:`return_inverse` is True, there will be a
2nd returned tensor (same shape as input) representing the indices
for where elements in the original input map to in the output;
otherwise, this function will only return a single tensor.
Example::
>>> output = torch.unique(torch.tensor([1, 3, 2, 3], dtype=torch.long))
>>> output
tensor([ 2, 3, 1])
>>> output, inverse_indices = torch.unique(
torch.tensor([1, 3, 2, 3], dtype=torch.long), sorted=True, return_inverse=True)
>>> output
tensor([ 1, 2, 3])
>>> inverse_indices
tensor([ 0, 2, 1, 2])
>>> output, inverse_indices = torch.unique(
torch.tensor([[1, 3], [2, 3]], dtype=torch.long), sorted=True, return_inverse=True)
>>> output
tensor([ 1, 2, 3])
>>> inverse_indices
tensor([[ 0, 2],
[ 1, 2]])
"""
if dim is not None:
output, inverse_indices = torch._unique_dim(
input,
dim,
sorted=sorted,
return_inverse=return_inverse
)
else:
output, inverse_indices = torch._unique(
input,
sorted=sorted,
return_inverse=return_inverse,
)
if return_inverse:
return output, inverse_indices
else:
return output
def unique(input, dim=None, names=("unique", "Indices"), **kwargs):
"""
Returns the unique elements of the input ntensor for a specific dimension.
Parameters
----------
input (NamedTensor) – the input ntensor
dim (string): the dimension to apply unique. If None, the unique of the flattened input is returned.
default: None
names (tuple of strings): the names for the output ntensor of unique elements and the output ntensor of
corresponding indices. default: ("unique", "Indices")
sorted (bool): Whether to sort the unique elements in ascending order before returning as output.
default: False
return_inverse (bool): Whether to also return the indices for where elements in the original input
ended up in the returned unique output. default: False
Returns:
----------
A namedtensor or a tuple of namedtensors containing
output (NamedTensor): the output ntensor of unique elements.
inverse_indices (NamedTensor): (optional) the output ntensor representing the indices for
where elements in the original input map to in the output.
"""
dim_name = dim
return_inverse = ("return_inverse" in kwargs
and kwargs["return_inverse"])
# If dim is not None, the output ntensor has the same dimensions as input while the dim is renamed,
# and the inverse_indices is an 1-D ntensor.
if dim is not None:
dim = input._schema.get(dim)
output, inverse_indices = torch._unique_dim(input.values,
dim=dim,
**kwargs)
output = NamedTensor(output,
input.dims).rename(dim_name, (names[0]))
if return_inverse:
inverse_indices = NamedTensor(inverse_indices, names[1])
# If dim is None, the output is an 1-D ntensor,
# and the inverse_indices has the same dimensions as input while the dimensions are renamed.
else:
output, inverse_indices = torch._unique(input.values, **kwargs)
output = NamedTensor(output, names[0])
if return_inverse:
inverse_indices = NamedTensor(
inverse_indices,
(["%s%s" % (s, names[1]) for s in input.dims]),
)
if return_inverse:
return output, inverse_indices
else:
return output
def unique(input, sorted=False, return_inverse=False):
r"""Returns the unique scalar elements of the input tensor as a 1-D tensor.
Arguments:
input (Tensor): the input tensor
sorted (bool): Whether to sort the unique elements in ascending order
before returning as output.
return_inverse (bool): Whether to also return the indices for where
elements in the original input ended up in the returned unique list.
Returns:
(Tensor, Tensor (optional)): A tensor or a tuple of tensors containing
- **output** (*Tensor*): the output list of unique scalar elements.
- **inverse_indices** (*Tensor*): (optional) if
:attr:`return_inverse` is True, there will be a
2nd returned tensor (same shape as input) representing the indices
for where elements in the original input map to in the output;
otherwise, this function will only return a single tensor.
Example::
>>> output = torch.unique(torch.tensor([1, 3, 2, 3], dtype=torch.long))
>>> output
tensor([ 2, 3, 1])
>>> output, inverse_indices = torch.unique(
torch.tensor([1, 3, 2, 3], dtype=torch.long), sorted=True, return_inverse=True)
>>> output
tensor([ 1, 2, 3])
>>> inverse_indices
tensor([ 0, 2, 1, 2])
>>> output, inverse_indices = torch.unique(
torch.tensor([[1, 3], [2, 3]], dtype=torch.long), sorted=True, return_inverse=True)
>>> output
tensor([ 1, 2, 3])
>>> inverse_indices
tensor([[ 0, 2],
[ 1, 2]])
"""
output, inverse_indices = torch._unique(
input,
sorted=sorted,
return_inverse=return_inverse,
)
if return_inverse:
return output, inverse_indices
else:
return output
def unique(self, sorted=True, return_inverse=False, dim=None):
r"""Returns the unique scalar elements of the tensor as a 1-D tensor.
See :func:`torch.unique`
"""
if dim is not None:
output, inverse_indices = torch._unique_dim(
self, sorted=sorted, return_inverse=return_inverse, dim=dim)
else:
output, inverse_indices = torch._unique(
self, sorted=sorted, return_inverse=return_inverse)
if return_inverse:
return output, inverse_indices
else:
return output
def unique(input, sorted=True, return_inverse=False, return_counts=False, dim=None):
r"""Returns the unique elements of the input tensor.
Arguments:
input (Tensor): the input tensor
sorted (bool): Whether to sort the unique elements in ascending order
before returning as output.
return_inverse (bool): Whether to also return the indices for where
elements in the original input ended up in the returned unique list.
return_counts (bool): Whether to also return the counts for each unique
element. Currently only supported when `dim` is not None.
dim (int): the dimension to apply unique. If ``None``, the unique of the
flattened input is returned. default: ``None``
Returns:
(Tensor, Tensor (optional) Tensor (optional))::
A tensor or a tuple of tensors containing
- **output** (*Tensor*): the output list of unique scalar elements.
- **inverse_indices** (*Tensor*): (optional) if
:attr:`return_inverse` is True, there will be an additional
returned tensor (same shape as input) representing the indices
for where elements in the original input map to in the output;
otherwise, this function will only return a single tensor.
- **counts** (*Tensor*): (optional) if
:attr:`return_counts` is True, there will be an additional
returned tensor (same shape as output or output.size(dim),
if dim was specified) representing the number of occurrences
for each unique value or tensor.
Example::
>>> output = torch.unique(torch.tensor([1, 3, 2, 3], dtype=torch.long))
>>> output
tensor([ 2, 3, 1])
>>> output, inverse_indices = torch.unique(
torch.tensor([1, 3, 2, 3], dtype=torch.long), sorted=True, return_inverse=True)
>>> output
tensor([ 1, 2, 3])
>>> inverse_indices
tensor([ 0, 2, 1, 2])
>>> output, inverse_indices = torch.unique(
torch.tensor([[1, 3], [2, 3]], dtype=torch.long), sorted=True, return_inverse=True)
>>> output
tensor([ 1, 2, 3])
>>> inverse_indices
tensor([[ 0, 2],
[ 1, 2]])
"""
if dim is not None:
output, inverse_indices, counts = torch._C._VariableFunctions.unique_dim(
input,
dim,
sorted=sorted,
return_inverse=return_inverse,
return_counts=return_counts,
)
else:
if return_counts:
raise NotImplementedError(
"torch.unique currently does not support return_counts with dim not None")
output, inverse_indices = torch._unique(
input,
sorted=sorted,
return_inverse=return_inverse
)
if return_inverse and return_counts:
return output, inverse_indices, counts
elif return_inverse:
return output, inverse_indices
elif return_counts:
return output, counts
else:
return output
def unique(input, sorted=False, return_inverse=False):
r"""Returns the unique scalar elements of the input tensor as a 1-D tensor.
Arguments:
input (Tensor): the input tensor
sorted (bool): Whether to sort the unique elements in ascending order
before returning as output.
return_inverse (bool): Whether to also return the indices for where
elements in the original input ended up in the returned unique list.
Returns:
(Tensor, Tensor (optional)): A tensor or a tuple of tensors containing
- **output** (*Tensor*): the output list of unique scalar elements.
- **inverse_indices** (*Tensor*): (optional) if
:attr:`return_inverse` is True, there will be a
2nd returned tensor (same shape as input) representing the indices
for where elements in the original input map to in the output;
otherwise, this function will only return a single tensor.
Example::
>>>> output = torch.unique(torch.LongTensor([1, 3, 2, 3]))
>>>> output
2
3
1
[torch.LongTensor of size (3,)]
>>>> output, inverse_indices = torch.unique(
torch.LongTensor([1, 3, 2, 3]), sorted=True, return_inverse=True)
>>>> output
1
2
3
[torch.LongTensor of size (3,)]
>>>> inverse_indices
0
2
1
2
[torch.LongTensor of size (4,)]
>>>> output, inverse_indices = torch.unique(
torch.LongTensor([[1, 3], [2, 3]]), sorted=True, return_inverse=True)
>>>> output
1
2
3
[torch.LongTensor of size (3,)]
>>>> inverse_indices
0 2
1 2
[torch.LongTensor of size (2,2)]
"""
output, inverse_indices = torch._unique(
input,
sorted=sorted,
return_inverse=return_inverse,
)
if return_inverse:
return output, inverse_indices
else:
return output
