DEV Community

Super Kai (Kazuya Ito)
Super Kai (Kazuya Ito)

Posted on • Updated on

gt(), lt(), ge() and le() in PyTorch

#pytorch #gt #lt #ge

My post explains equal(), eq() and ne().

gt() can check the zero or more elements of the 1st 0D or more D tensor are greater than the zero or more elements of the 2nd 0D or more D tensor element-wise as shown below:

*Memos:

  • gt() can be used with torch or a tensor.
  • The 1st argument(tensor of int, float or bool) with torch or using a tensor(tensor of int, float or bool) is input(Required).
  • The 2nd argument(tensor or scalar of int, float or bool) with torch or the 1st argument with a tensor(tensor or scalar of int, float or bool) is other(Required).
  • greater() is the alias of gt(). 
import torch

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

torch.gt(input=tensor2, other=tensor1)
# tensor([[False, False, False],
#         [True, False, False]])

torch.gt(input=tensor1, other=3)
# tensor(True)

torch.gt(input=tensor2, other=3)
# tensor([[False, True, True],
#         [True, False, True]])

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

torch.gt(input=tensor2, other=tensor1)
# tensor([[[False, True, False], [True, True, False]],
#         [[False, False, True], [True, True, True]]])

torch.gt(input=tensor1, other=3)
# tensor([True, False, False])

torch.gt(input=tensor2, other=3)
# tensor([[[False, True, False], [True, False, False]],
#         [[True, False, True], [True, True, True]]])

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

torch.gt(input=tensor2, other=tensor1)
# tensor([[[False, False, False], [False, False, False]],
#         [[False, True, False], [False, True, False]]])

torch.gt(input=tensor1, other=3.)
# tensor([True, False, False])

torch.gt(input=tensor1, other=False)
# tensor([True, False, True])

torch.gt(input=tensor2, other=3.)
# tensor([[[False, False, False], [False, False, False]],
#         [[False, False, False], [False, False, False]]])

torch.gt(input=tensor2, other=False)
# tensor([[[True, False, True], [True, False, True]],
#         [[False, True, False], [False, True, False]]])
Enter fullscreen mode Exit fullscreen mode

lt() can check the zero or more elements of the 1st 0D or more D tensor are less than the zero or more elements of the 2nd 0D or more D tensor element-wise as shown below:

*Memos:

  • lt() can be used with torch or a tensor.
  • The 1st argument(tensor of int, float or bool) with torch or using a tensor(tensor of int, float or bool) is input(Required).
  • The 2nd argument(tensor or scalar of int, float or bool) with torch or the 1st argument with a tensor(tensor or scalar of int, float or bool) is other(Required).
  • less() is the alias of lt(). 
import torch

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

torch.lt(input=tensor2, other=tensor1)
# tensor([[True, False, True],
#         [False, True, False]])

torch.lt(input=tensor1, other=3)
# tensor(False)

torch.lt(input=tensor2, other=3)
# tensor([[False, False, False],
#         [False, False, False]])

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

torch.lt(input=tensor2, other=tensor1)
# tensor([[[True, False, False], [False, False, True]],
#         [[False, False, False], [False, False, False]]])

torch.lt(input=tensor1, other=3)
# tensor([False, True, False])

torch.lt(input=tensor2, other=3)
# tensor([[[True, False, False], [False, False, True]],
#         [[False, True, False], [False, False, False]]])

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

torch.lt(input=tensor2, other=tensor1)
# tensor([[[True, False, True], [True, False, True]],
#         [[True, False, True], [True, False, True]]])

torch.lt(input=tensor1, other=3.)
# tensor([False, True, False])

torch.lt(input=tensor1, other=False)
# tensor([False, False, False])

torch.lt(input=tensor2, other=3.)
# tensor([[[True, True, True], [True, True, True]],
#         [[True, True, True], [True, True, True]]])

torch.lt(input=tensor2, other=False)
# tensor([[[False, False, False], [False, False, False]],
#         [[False, False, False], [False, False, False]]])
Enter fullscreen mode Exit fullscreen mode

ge() can check the zero or more elements of the 1st 0D or more D tensor are greater than or equal to the zero or more elements of the 2nd 0D or more D tensor element-wise as shown below:

*Memos:

  • ge() can be used with torch and a tensor.
  • The 1st argument(tensor of int, float or bool) with torch or using a tensor(tensor of int, float or bool) is input(Required).
  • The 2nd argument(tensor or scalar of int, float or bool) with torch or the 1st argument with a tensor(tensor or scalar of int, float or bool) is other(Required).
  • greater_equal() is the alias of ge(). 
import torch

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

torch.ge(input=tensor2, other=tensor1)
# tensor([[False, True, False],
#         [True, False, True]])

torch.ge(input=tensor1, other=3)
# tensor(True)

torch.ge(input=tensor2, other=3)
# tensor([[True, True, True],
#         [True, True, True]])

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

torch.ge(input=tensor2, other=tensor1)
# tensor([[[False, True, True], [True, True, False]],
#         [[True, True, True], [True, True, True]]])

torch.ge(input=tensor1, other=3)
# tensor([True, False, True])

torch.ge(input=tensor2, other=3)
# tensor([[[False, True, True], [True, True, False]],
#         [[True, False, True], [True, True, True]]])

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

torch.ge(input=tensor2, other=tensor1)
# tensor([[[False, True, False], [False, True, False]],
#         [[False, True, False], [False, True, False]]])

torch.ge(input=tensor1, other=3.)
# tensor([True, False, True])

torch.ge(input=tensor1, other=False)
# tensor([True, True, True])

torch.ge(input=tensor2, other=3.)
# tensor([[[False, False, False], [False, False, False]],
#         [[False, False, False], [False, False, False]]])

torch.ge(input=tensor2, other=False)
# tensor([[[True, True, True], [True, True, True]],
#         [[True, True, True], [True, True, True]]])
Enter fullscreen mode Exit fullscreen mode

le() can check the zero or more elements of the 1st 0D or more D tensor are less than or equal to the zero or more elements of the 2nd 0D or more D tensor element-wise as shown below:

*Memos:

  • le() can be used with torch and a tensor.
  • The 1st argument(tensor of int, float or bool) with torch or using a tensor(tensor of int, float or bool) is input(Required).
  • The 2nd argument(tensor or scalar of int, float or bool) with torch or the 1st argument with a tensor(tensor or scalar of int, float or bool) is other(Required).
  • less_equal() is the alias of le(). 
import torch

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

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

torch.le(input=tensor1, other=3)
# tensor(False)

torch.le(input=tensor2, other=3)
# tensor([[True, False, False],
#         [False, True, False]])

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

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

torch.le(input=tensor1, other=3)
# tensor([False, True, True])

torch.le(input=tensor2, other=3)
# tensor([[[True, False, True], [False, True, True]],
#         [[False, True, False], [False, False, False]]])

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

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

torch.le(input=tensor1, other=3.)
# tensor([False, True, True])

torch.le(input=tensor1, other=False)
# tensor([False, True, False])

torch.le(input=tensor2, other=3.)
# tensor([[[True, True, True], [True, True, True]],
#         [[True, True, True],        [True, True, True]]])

torch.le(input=tensor2, other=False)
# tensor([[[False, True, False], [False, True, False]],
#         [[True, False, True], [True, False, True]]])
Enter fullscreen mode Exit fullscreen mode

Top comments (0)

Read next

lukman_saidmodibbo_be550 profile image

ReactJS vs. React Native: A Beginner's Guide

LUKMAN SAID MODIBBO -

eric_dequ profile image

Relationship-Based IoT Models Enhancing Accuracy Efficiency and Security

Eric Dequevedo -

kodsama profile image

Controlling AWS Lambda Costs

Kodsama -

caiofior profile image

Accessing Azure storage with a shared key in php

Claudio Fior -