torch.unique

torch.unique(input, sorted=True, return_inverse=False, return_counts=False, dim=None) → tuple[Tensor, Tensor, Tensor] [исходный код]

Возвращает уникальные элементы входного тензора.

Примечание

Эта функция отличается от torch.unique_consecutive() тем, что она также удаляет непоследовательные повторяющиеся значения.

Примечание

В текущих реализациях для CUDA и CPU torch.unique всегда сортируют тензор в начале независимо от значения аргумента sort. Сортировка может быть медленной, поэтому, если входной тензор уже отсортирован, рекомендуется использовать torch.unique_consecutive(), которая позволяет избежать сортировки.

Параметры:

• input (Tensor) – входной тензор
• sorted (bool) – Нужно ли перед возвратом отсортировать уникальные элементы по возрастанию.
• return_inverse (bool) – Нужно ли также возвращать индексы, указывающие, куда попали элементы исходного входного тензора в возвращаемом списке уникальных элементов.
• return_counts (bool) – Нужно ли также возвращать количество вхождений каждого уникального элемента.
• dim (int, optional) – измерение, для которого выполняется операция. Если None, возвращаются уникальные элементы расплющенного входного тензора. В противном случае каждый тензор, индексируемый по заданному измерению, рассматривается как элемент, к которому применяется операция поиска уникальных элементов. Важно: если задано dim, операция ищет уникальные подтензоры (например, уникальные строки или столбцы), а не уникальные скалярные значения. Это означает, что отдельные значения могут встречаться в выходных данных несколько раз, если они присутствуют в разных подтензорах. Подробнее см. примеры. По умолчанию: None

Возвращает:

Тензор или кортеж тензоров, содержащий

• output (Tensor): список уникальных скалярных элементов, если dim равно None; в противном случае — уникальные подтензоры вдоль указанного измерения. Обратите внимание: если задано dim, скалярные значения могут повторяться в выходных данных.
• inverse_indices (Tensor): (необязательно) если return_inverse имеет значение True, дополнительно возвращается тензор (той же формы, что и входной), содержащий индексы, указывающие, куда в выходных данных отображаются элементы исходного входного тензора; в противном случае эта функция возвращает только один тензор.
• counts (Tensor): (необязательно) если return_counts имеет значение True, дополнительно возвращается тензор (той же формы, что и output или output.size(dim), если задан dim), содержащий количество вхождений каждого уникального значения или тензора.

Тип возвращаемого значения:

(Tensor, Tensor (необязательно), Tensor (необязательно))

Пример:

>>> output = torch.unique(torch.tensor([1, 3, 2, 3], dtype=torch.long))
>>> output
tensor([1, 2, 3])

>>> 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]])

>>> # When using dim, the operation finds unique sub-tensors, not unique values.
>>> # Notice how values can repeat in the output:
>>> x = torch.tensor([[1, 3, 2, 3], [1, 2, 1, 2]], dtype=torch.long)
>>> torch.unique(x, dim=0)  # unique rows
tensor([[1, 2, 1, 2],
        [1, 3, 2, 3]])
>>> # Both rows are kept because they're different from each other,
>>> # even though values 1, 2, 3 appear multiple times in the output.
>>> torch.unique(x, dim=1)  # unique columns
tensor([[1, 2, 3],
        [1, 1, 2]])
>>> # The value 1 appears twice because we're comparing columns, not values.
>>> # Compare with flattened (no dim):
>>> torch.unique(x)
tensor([1, 2, 3])

>>> a = torch.tensor([
...     [
...         [1, 1, 0, 0],
...         [1, 1, 0, 0],
...         [0, 0, 1, 1],
...     ],
...     [
...         [0, 0, 1, 1],
...         [0, 0, 1, 1],
...         [1, 1, 1, 1],
...     ],
...     [
...         [1, 1, 0, 0],
...         [1, 1, 0, 0],
...         [0, 0, 1, 1],
...     ],
... ])

>>> # If we call `torch.unique(a, dim=0)`, each of the tensors `a[idx, :, :]`
>>> # will be compared. We can see that `a[0, :, :]` and `a[2, :, :]` match
>>> # each other, so one of them will be removed.
>>> (a[0, :, :] == a[2, :, :]).all()
tensor(True)
>>> a_unique_dim0 = torch.unique(a, dim=0)
>>> a_unique_dim0
tensor([[[0, 0, 1, 1],
         [0, 0, 1, 1],
         [1, 1, 1, 1]],
        [[1, 1, 0, 0],
         [1, 1, 0, 0],
         [0, 0, 1, 1]]])

>>> # Notice which sub-tensors from `a` match with the sub-tensors from
>>> # `a_unique_dim0`:
>>> (a_unique_dim0[0, :, :] == a[1, :, :]).all()
tensor(True)
>>> (a_unique_dim0[1, :, :] == a[0, :, :]).all()
tensor(True)

>>> # For `torch.unique(a, dim=1)`, each of the tensors `a[:, idx, :]` are
>>> # compared. `a[:, 0, :]` and `a[:, 1, :]` match each other, so one of
>>> # them will be removed.
>>> (a[:, 0, :] == a[:, 1, :]).all()
tensor(True)
>>> torch.unique(a, dim=1)
tensor([[[0, 0, 1, 1],
         [1, 1, 0, 0]],
        [[1, 1, 1, 1],
         [0, 0, 1, 1]],
        [[0, 0, 1, 1],
         [1, 1, 0, 0]]])

>>> # For `torch.unique(a, dim=2)`, the tensors `a[:, :, idx]` are compared.
>>> # `a[:, :, 0]` and `a[:, :, 1]` match each other. Also, `a[:, :, 2]` and
>>> # `a[:, :, 3]` match each other as well. So in this case, two of the
>>> # sub-tensors will be removed.
>>> (a[:, :, 0] == a[:, :, 1]).all()
tensor(True)
>>> (a[:, :, 2] == a[:, :, 3]).all()
tensor(True)
>>> torch.unique(a, dim=2)
tensor([[[0, 1],
         [0, 1],
         [1, 0]],
        [[1, 0],
         [1, 0],
         [1, 1]],
        [[0, 1],
         [0, 1],
         [1, 0]]])