15.04.2024 в 15:19

Функции gt(), lt(), ge() и le() в PyTorch

В моем посте объясняются функции equal(), eq() и ne().

gt() может проверить, больше ли 1-й тензор 2-го тензора по элементам, как показано ниже:

Памятка:

gt() можно вызывать как из torch, так и из тензора.
Тензоры могут быть 0D или более D-тензорами.
Одно или несколько комплексных чисел использовать нельзя.
gt() и greater() - это одно и то же, потому что greater() - это сокращение от gt():

import torch

tensor1 = torch.tensor(5)
tensor2 = torch.tensor([[3, 5, 4], [6, 3, 5]])
torch.gt(tensor1, tensor2)
tensor1.gt(tensor2)
# tensor([[True, False, True], [False,  True, False]])
torch.gt(tensor2, tensor1)
tensor2.gt(tensor1)
# tensor([[False, False, False], [ True, False, False]])

tensor1 = torch.tensor([[5, 0, 3]])
tensor2 = torch.tensor([[5, 5, 5], [0, 0, 0], [3, 3, 3]])
torch.gt(tensor1, tensor2)
tensor1.gt(tensor2)
# tensor([[False, False, False],
#         [True, False, True], 
#         [True, False, False]])
torch.gt(tensor2, tensor1)
tensor2.gt(tensor1)
# tensor([[False, True, True],
#         [False, False, False],
#         [False, True, False]])

tensor1 = torch.tensor([[5, 0, 3], [6, 9, 1]])
tensor2 = torch.tensor([[[2, 7, 3], [6, 3, 1]],
                        [[5, 0, 4], [8, 9, 7]]])
torch.gt(tensor1, tensor2)
tensor1.gt(tensor2)
# tensor([[[True, False, False], [False, True, False]],
#         [[False, False, False], [False, False, False]]])
torch.gt(tensor2, tensor1)
tensor2.gt(tensor1)
# tensor([[[False, True, False], [False, False, False]],
#         [[False, False, True], [True, False, True]]])

tensor1 = torch.tensor([[5, 0, 3], [6, 9, 1]])
tensor2 = torch.tensor([[[2., 7., 3.], [6., 3., True]],
                        [[5., False, 4.], [8., 9., 7.]]])
torch.gt(tensor1, tensor2)
tensor1.gt(tensor2)
# tensor([[[True, False, False], [False, True, False]],
#         [[False, False, False], [False, False, False]]])
torch.gt(tensor2, tensor1)
tensor2.gt(tensor1)
# tensor([[[False, True, False], [False, False, False]],
#         [[False, False, True], [True, False, True]]])

tensor1 = torch.tensor([[6, 9, 1], [5, 0, 3]])
tensor2 = torch.tensor([[[2, 7, 3], [6, 3, 1]],
                        [[5, 0, 4], [8, 9, 7]]])
torch.gt(tensor1, tensor2)
tensor1.gt(tensor2)
# tensor([[[True, True, False], [False, False, True]],
#         [[True, True, False], [False, False, False]]])
torch.gt(tensor2, tensor1)
tensor2.gt(tensor1)
# tensor([[[False, False, True], [True, True, False]],
#         [[False, False, True], [True, True, True]]])

lt() может проверить, меньше ли 1-й тензор по элементам, чем 2-й тензор, как показано ниже:

Памятка:

lt() может быть вызвана как из torch, так и из тензора.
Тензоры могут быть 0D или более D тензоров.
Одно или несколько комплексных чисел использовать нельзя.
lt() и less() - это одно и то же, потому что less() - это сокращение от lt():

import torch

tensor1 = torch.tensor(5)
tensor2 = torch.tensor([[3, 5, 4], [6, 3, 5]])
torch.lt(tensor1, tensor2)
tensor1.lt(tensor2)
# tensor([[False, False, False], [True, False, False]])
torch.lt(tensor2, tensor1)
tensor2.lt(tensor1)
# tensor([[ True, False, True], [False, True, False]])

tensor1 = torch.tensor([[5, 0, 3]])
tensor2 = torch.tensor([[5, 5, 5], [0, 0, 0], [3, 3, 3]])
torch.lt(tensor1, tensor2)
tensor1.lt(tensor2)
# tensor([[False, True, True],
#         [False, False, False],
#         [False, True, False]])
torch.lt(tensor2, tensor1)
tensor2.lt(tensor1)
# tensor([[False, False, False],
#         [True, False, True],
#         [True, False, False]])

tensor1 = torch.tensor([[5, 0, 3], [6, 9, 1]])
tensor2 = torch.tensor([[[2, 7, 3], [6, 3, 1]],
                        [[5, 0, 4], [8, 9, 7]]])
torch.lt(tensor1, tensor2)
tensor1.lt(tensor2)
# tensor([[[False, True, False], [False, False, False]],
#         [[False, False, True], [True, False, True]]])
torch.lt(tensor2, tensor1)
tensor2.lt(tensor1)
# tensor([[[True, False, False], [False, True, False]],
#         [[False, False, False], [False, False, False]]])

tensor1 = torch.tensor([[5, 0, 3], [6, 9, 1]])
tensor2 = torch.tensor([[[2., 7., 3.], [6., 3., True]],
                        [[5., False, 4.], [8., 9., 7.]]])
torch.lt(tensor1, tensor2)
tensor1.lt(tensor2)
# tensor([[[False,  True, False], [False, False, False]],
#         [[False, False, True], [True, False, True]]])
torch.lt(tensor2, tensor1)
tensor2.lt(tensor1)
# tensor([[[True, False, False], [False, True, False]],
#         [[False, False, False], [False, False, False]]])

tensor1 = torch.tensor([[6, 9, 1], [5, 0, 3]])
tensor2 = torch.tensor([[[2, 7, 3], [6, 3, 1]],
                        [[5, 0, 4], [8, 9, 7]]])
torch.lt(tensor1, tensor2)
tensor1.lt(tensor2)
# tensor([[[False, False, True], [True, True, False]],
#        [[False, False, True], [True, True, True]]])
torch.lt(tensor2, tensor1)
tensor2.lt(tensor1)
# tensor([[[True, True, False], [False, False, True]],
#         [[True, True, False], [False, False, False]]])

ge() может проверить, больше или равен ли 1-й тензор 2-му тензору по элементам, как показано ниже:

Памятка:

ge() может вызываться как из torch, так и из тензора.
Тензоры могут быть 0D или более D тензоров.
Одно или несколько комплексных чисел использовать нельзя.
ge() и greater_equal() - это одно и то же, потому что greater_equal() - это сокращение от ge():

import torch

tensor1 = torch.tensor(5)
tensor2 = torch.tensor([[3, 5, 4], [6, 3, 5]])
torch.ge(tensor1, tensor2)
tensor1.ge(tensor2)
# tensor([[True, True, True], [False, True, True]])
torch.ge(tensor2, tensor1)
tensor2.ge(tensor1)
# tensor([[False, True, False], [True, False, True]])

tensor1 = torch.tensor([[5, 0, 3]])
tensor2 = torch.tensor([[5, 5, 5], [0, 0, 0], [3, 3, 3]])
torch.ge(tensor1, tensor2)
tensor1.ge(tensor2)
# tensor([[True, False, False],
#         [True, True, True],
#         [True, False, True]])
torch.ge(tensor2, tensor1)
tensor2.ge(tensor1)
# tensor([[True, True, True],
#         [False, True, False],
#         [False, True, True]])

tensor1 = torch.tensor([[5, 0, 3], [6, 9, 1]])
tensor2 = torch.tensor([[[2, 7, 3], [6, 3, 1]],
                        [[5, 0, 4], [8, 9, 7]]])
torch.ge(tensor1, tensor2)
tensor1.ge(tensor2)
# tensor([[[True, False, True], [True, True, True]],
#         [[True, True, False], [False, True, False]]])
torch.ge(tensor2, tensor1)
tensor2.ge(tensor1)
# tensor([[[False, True, True], [True, False, True]],
#         [[True, True, True], [True, True, True]]])

tensor1 = torch.tensor([[5, 0, 3], [6, 9, 1]])
tensor2 = torch.tensor([[[2., 7., 3.], [6., 3., True]],
                        [[5., False, 4.], [8., 9., 7.]]])
torch.ge(tensor1, tensor2)
tensor1.ge(tensor2)
# tensor([[[True, False, True], [True, True, True]],
#         [[True, True, False], [False, True, False]]])
torch.ge(tensor2, tensor1)
tensor2.ge(tensor1)
# tensor([[[False, True, True], [True, False, True]],
#         [[True, True, True], [True, True, True]]])

tensor1 = torch.tensor([[6, 9, 1], [5, 0, 3]])
tensor2 = torch.tensor([[[2, 7, 3], [6, 3, 1]],
                        [[5, 0, 4], [8, 9, 7]]])
torch.ge(tensor1, tensor2)
tensor1.ge(tensor2)
# tensor([[[True, True, False], [False, False, True]],
#         [[True, True, False], [False, False, False]]])
torch.ge(tensor2, tensor1)
tensor2.ge(tensor1)
# tensor([[[False, False, True], [True, True, False]],
#         [[False, False, True], [True, True, True]]])

le() может проверить, меньше или равен ли 1-й тензор 2-му тензору по элементам, как показано ниже:

Памятка:

le() может вызываться как из torch, так и из тензора.
Тензоры могут быть 0D или более D тензоров.
Одно или несколько комплексных чисел использовать нельзя.
le() и less_equal() - это одно и то же, потому что less_equal() - это сокращение le():

import torch

tensor1 = torch.tensor(5)
tensor2 = torch.tensor([[3, 5, 4], [6, 3, 5]])
torch.le(tensor1, tensor2)
tensor1.le(tensor2)
# tensor([[False, True, False],　[True, False, True]])

torch.le(tensor2, tensor1)
tensor2.le(tensor1)
# tensor([[True, True, True], [False, True, True]])

tensor1 = torch.tensor([[5, 0, 3]])
tensor2 = torch.tensor([[5, 5, 5], [0, 0, 0], [3, 3, 3]])
torch.le(tensor1, tensor2)
tensor1.le(tensor2)
# tensor([[True, True, True],
#         [False, True, False],
#         [False, True, True]])
torch.le(tensor2, tensor1)
tensor2.le(tensor1)
# tensor([[True, False, False],
#         [True, True, True],
#         [True, False, True]])

tensor1 = torch.tensor([[5, 0, 3], [6, 9, 1]])
tensor2 = torch.tensor([[[2, 7, 3], [6, 3, 1]],
                        [[5, 0, 4], [8, 9, 7]]])
torch.le(tensor1, tensor2)
tensor1.le(tensor2)
# tensor([[[False, True, True], [True, False, True]],
#         [[True, True, True], [True, True, True]]])
torch.le(tensor2, tensor1)
tensor2.le(tensor1)
# tensor([[[True, False, True], [True, True, True]],
#         [[True, True, False], [False, True, False]]])

tensor1 = torch.tensor([[5, 0, 3], [6, 9, 1]])
tensor2 = torch.tensor([[[2., 7., 3.], [6., 3., True]],
                        [[5., False, 4.], [8., 9., 7.]]])
torch.le(tensor1, tensor2)
tensor1.le(tensor2)
# tensor([[[False, True, True], [True, False, True]],
#         [[True, True, True], [True, True, True]]])
torch.le(tensor2, tensor1)
tensor2.le(tensor1)
# tensor([[[True, False, True], [True, True, True]],
#         [[True, True, False], [False, True, False]]])

tensor1 = torch.tensor([[6, 9, 1], [5, 0, 3]])
tensor2 = torch.tensor([[[2, 7, 3], [6, 3, 1]],
                        [[5, 0, 4], [8, 9, 7]]])
torch.le(tensor1, tensor2)
tensor1.le(tensor2)
# tensor([[[False, False, True], [True, True, False]],
#         [[False, False, True], [True, True, True]]])
torch.le(tensor2, tensor1)
tensor2.le(tensor1)
# tensor([[[True, True, False], [False, False, True]],
#         [[True, True, False], [False, False, False]]])

Для дополнительного изучения прилагаем статью о разделении 1D или более D тензор на 1 или несколько тензоров.

Источник:

Exit fullscreen mode

#Python

Войти на сайт

Функции gt(), lt(), ge() и le() в PyTorch

Источник: