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