torch.unique

torch.unique(input, sorted=True, return_inverse=False, return_counts=False, dim=None) → Tuple[Tensor, Tensor, Tensor]

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

Примечание

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

Примечание

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

Параметры

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

Возвращает

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

• output (Tensor): список выходных уникальных скалярных элементов.
• 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]])

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