arange(), linspace() and logspace() in PyTorch

arange() can create the 1D tensor of zero or integers or floating-point numbers between start and end-1(start<=x<=end-1)as shown below:

*Memos:

arange() can be used with torch but not with a tensor.
The 1st argument with torch is start(Option…


This content originally appeared on DEV Community and was authored by Super Kai (Kazuya Ito)

arange() can create the 1D tensor of zero or integers or floating-point numbers between start and end-1(start<=x<=end-1)as shown below:

*Memos:

  • arange() can be used with torch but not with a tensor.
  • The 1st argument with torch is start(Optional-Default:0-Type:int, float, complex or bool): *Memos
    • It must be lower than or equal to end.
    • The 0D tensor of int, float, complex or bool also works.
  • The 2nd argument with torch is end(Required-Type:int, float, complex or bool): *Memos:
    • It must be greater than or equal to start.
    • The 0D tensor of int, float, complex or bool also works.
  • The 3rd argument with torch is step(Optional-Default:1-Type:int, float, complex or bool): *Memos:
    • It must be greater than 0.
    • The 0D tensor of int, float, complex or bool also works.
  • There is dtype argument with torch(Optional-Type:dtype): *Memos:
    • If dtype is not given, dtype is inferred from start, end or step or dtype of set_default_dtype() is used for floating-point numbers.
    • dtype= must be used.
    • My post explains dtype argument.
  • There is device argument with torch(Optional-Type:str, int or device()): *Memos:
    • device= must be used.
    • My post explains device argument.
  • There is requires_grad argument with torch(Optional-Type:bool): *Memos:
    • requires_grad= must be used.
    • My post explains requires_grad argument.
  • There is out argument with torch(Optional-Type:tensor): *Memos:
    • out= must be used.
    • My post explains out argument.
  • There is range() which is similar to arange() but range() is deprecated. 
import torch

torch.arange(end=5)
# tensor([0, 1, 2, 3, 4])

torch.arange(start=5, end=15)
# tensor([5, 6, 7, 8, 9, 10, 11, 12, 13, 14])

torch.arange(start=5, end=15, step=3)
# tensor([5, 8, 11, 14])

torch.arange(start=-5, end=5)
# tensor([-5, -4, -3, -2, -1, 0, 1, 2, 3, 4])

torch.arange(start=-5, end=5, step=3)
torch.arange(start=torch.tensor(-5),
             end=torch.tensor(5),
             step=torch.tensor(3))
# tensor([-5, -2, 1, 4])

torch.arange(start=-5., end=5., step=3.)
torch.arange(start=torch.tensor(-5.),
             end=torch.tensor(5.),
             step=torch.tensor(3.))
# tensor([-5., -2., 1., 4.])

torch.arange(start=-5.+0.j, end=5.+0.j, step=3.+0.j)
torch.arange(start=torch.tensor(-5.+0.j),
             end=torch.tensor(5.+0.j),
             step=torch.tensor(3.+0.j))
# tensor([-5., -2., 1., 4.])

torch.arange(start=False, end=True, step=True)
torch.arange(start=torch.tensor(False),
             end=torch.tensor(True),
             step=torch.tensor(True))
# tensor([0])

linspace() can create the 1D tensor of the zero or more integers, floating-point numbers or complex numbers evenly spaced between start and end(start<=x<=end) as shown below:

*Memos:

  • linspace() can be used with torch but not with a tensor.
  • The 1st argument with torch is start(Required-Type:int, float, complex or bool). *The 0D tensor of int, float, complex or bool also works.
  • The 2nd argument with torch is end(Required-Type:int, float, complex or bool). *The 0D tensor of int, float, complex or bool also works.
  • The 3rd argument with torch is steps(Required-Type:int): *Memos:
    • It must be greater than or equal to 0.
    • The 0D tensor of int also works.
  • There is dtype argument with torch(Optional-Type:dtype): *Memos:
    • If dtype is not given, dtype is inferred from start, end or step or dtype of set_default_dtype() is used for floating-point numbers.
    • Setting start and end of integer type is not enough to create the 1D tensor of integer type so integer type with dtype must be set.
    • The 1D tensor of boolean type cannot be created.
    • dtype= must be used.
    • My post explains dtype argument.
  • There is device argument with torch(Optional-Type:str, int or device()): *Memos:
    • device= must be used.
    • My post explains device argument.
  • There is requires_grad argument with torch(Optional-Type:bool): *Memos:
    • requires_grad= must be used.
    • My post explains requires_grad argument.
  • There is out argument with torch(Optional-Type:tensor): *Memos:
    • out= must be used.
    • My post explains out argument. 
import torch

torch.linspace(start=10, end=20, steps=0)
torch.linspace(start=20, end=10, steps=0)
# tensor([])

torch.linspace(start=10., end=20., steps=1)
tensor([10.])

torch.linspace(start=20, end=10, steps=1)
# tensor([20.])

torch.linspace(start=10., end=20., steps=2)
# tensor([10., 20.])

torch.linspace(start=20, end=10, steps=2)
# tensor([20., 10.])

torch.linspace(start=10., end=20., steps=3)
# tensor([10., 15., 20.])

torch.linspace(start=20, end=10, steps=3)
# tensor([20., 15., 10.])

torch.linspace(start=10., end=20., steps=4)
# tensor([10.0000, 13.3333, 16.6667, 20.0000])

torch.linspace(start=20., end=10., steps=4)
# tensor([20.0000, 16.6667, 13.3333, 10.0000])

torch.linspace(start=10, end=20, steps=4, dtype=torch.int64)
torch.linspace(start=torch.tensor(10),
               end=torch.tensor(20),
               steps=torch.tensor(4),
               dtype=torch.int64)
# tensor([10.0000, 13.3333, 16.6667, 20.0000])

torch.linspace(start=10.+6.j, end=20.+3.j, steps=4)
torch.linspace(start=torch.tensor(10.+6.j),
               end=torch.tensor(20.+3.j),
               steps=torch.tensor(4))
# tensor([10.0000+6.j, 13.3333+5.j, 16.6667+4.j, 20.0000+3.j])

torch.linspace(start=False, end=True, steps=4)
torch.linspace(start=torch.tensor(True),
               end=torch.tensor(False),
               steps=torch.tensor(4))
# tensor([0.0000, 0.3333, 0.6667, 1.0000])

torch.linspace(start=10, end=20, steps=4, dtype=torch.int64)
torch.linspace(start=torch.tensor(10),
               end=torch.tensor(20),
               steps=torch.tensor(4), dtype=torch.int64)
# tensor([10.0000, 13.3333, 16.6667, 20.0000])

logspace() can create the 1D tensor of the zero or more integers, floating-point numbers or complex numbers evenly spaced between basestart and baseend(basestart<=x<=baseend) as shown below:

*Memos:

  • logspace() can be used with torch but not with a tensor.
  • The 1st argument with torch is start(Required-Type:int, float, complex or bool). *The 0D tensor of int, float, complex or bool also works.
  • The 2nd argument with torch is end(Required-Type:int, float, complex or bool). *The 0D tensor of int, float, complex or bool also works.
  • The 3rd argument with torch is steps(Required-Type:int): *Memos:
    • It must be greater than or equal to 0.
    • The 0D tensor of int also works.
  • The 4th argument with torch is base(Optional-Default:10.0-Type:int, float or bool). *The 0D tensor of int, float, complex or bool also works.
  • There is dtype argument with torch(Optional-Type:dtype): *Memos:
    • If dtype is not given, dtype is inferred from start, end or step or dtype of set_default_dtype() is used for floating-point numbers.
    • Setting start and end of integer type is not enough to create the 1D tensor of integer type so integer type with dtype must be set.
    • dtype= must be used.
    • My post explains dtype argument.
  • There is device argument with torch(Optional-Type:str, int or device()): *Memos:
    • device= must be used.
    • My post explains device argument.
  • There is requires_grad argument with torch(Optional-Type:bool): *Memos:
    • requires_grad= must be used.
    • My post explains requires_grad argument.
  • There is out argument with torch(Optional-Type:tensor): *Memos:
    • out= must be used.
    • My post explains out argument. 
import torch

torch.logspace(start=10., end=20., steps=0)
torch.logspace(start=10., end=20., steps=0, base=10.)
torch.logspace(start=20., end=10., steps=0)
torch.logspace(start=20., end=10., steps=0, base=10.)
# tensor([])

torch.logspace(start=10., end=20., steps=1)
torch.logspace(start=10., end=20., steps=1, base=10.)
# tensor([1.0000e+10])

torch.logspace(start=20., end=10., steps=1)
torch.logspace(start=20., end=10., steps=1, base=10.)
# tensor([1.0000e+20])

torch.logspace(start=10., end=20., steps=2)
torch.logspace(start=10., end=20., steps=2, base=10.)
# tensor([1.0000e+10, 1.0000e+20])

torch.logspace(start=20., end=10., steps=2)
torch.logspace(start=20., end=10., steps=2, base=10.)
# tensor([1.0000e+20, 1.0000e+10])

torch.logspace(start=10., end=20., steps=3)
torch.logspace(start=10., end=20., steps=3, base=10.)
# tensor([1.0000e+10, 1.0000e+15, 1.0000e+20])

torch.logspace(start=20., end=10., steps=3)
torch.logspace(start=20., end=10., steps=3, base=10.)
# tensor([1.0000e+20, 1.0000e+15, 1.0000e+10])

torch.logspace(start=10., end=20., steps=4)
torch.logspace(start=10., end=20., steps=4, base=10.)
# tensor([1.0000e+10, 2.1544e+13, 4.6416e+16, 1.0000e+20])

torch.logspace(start=20., end=10., steps=4)
torch.logspace(start=20., end=10., steps=4, base=10.)
# tensor([1.0000e+20, 4.6416e+16, 2.1544e+13, 1.0000e+10])

torch.logspace(start=10., end=20., steps=4, base=100.)
# tensor([1.0000e+20, 4.6416e+26, 2.1544e+33, inf])

torch.logspace(start=20., end=10., steps=4, base=100.)
# tensor([inf, 2.1544e+33, 4.6416e+26, 1.0000e+20])

torch.logspace(start=10, end=20, steps=4, base=10, dtype=torch.int64)
torch.logspace(start=torch.tensor(10),
               end=torch.tensor(20),
               steps=torch.tensor(4),
               base=torch.tensor(10),
               dtype=torch.int64)
# tensor([10000000000,
#         21544346900318,
#         46415888336127912,
#         -9223372036854775808])

torch.logspace(start=10.+6.j, end=20.+3.j, steps=4)
torch.logspace(start=torch.tensor(10.+6.j),
               end=torch.tensor(20.+3.j),
               steps=torch.tensor(4),
               base=torch.tensor(10.+0.j))
# tensor([3.1614e+09+9.4871e+09j,
#         1.0655e+13-1.8725e+13j,
#         -4.5353e+16+9.8772e+15j,
#         8.1122e+19+5.8475e+19j])

torch.logspace(start=False, end=True, steps=4, base=False)
torch.logspace(start=torch.tensor(False),
               end=torch.tensor(True),
               steps=torch.tensor(4),
               base=torch.tensor(False))
# tensor([1., 0., 0., 0.])


This content originally appeared on DEV Community and was authored by Super Kai (Kazuya Ito)


Print Share Comment Cite Upload Translate Updates
APA

Super Kai (Kazuya Ito) | Sciencx (2024-07-10T13:52:52+00:00) arange(), linspace() and logspace() in PyTorch. Retrieved from https://www.scien.cx/2024/07/10/arange-linspace-and-logspace-in-pytorch/

MLA
" » arange(), linspace() and logspace() in PyTorch." Super Kai (Kazuya Ito) | Sciencx - Wednesday July 10, 2024, https://www.scien.cx/2024/07/10/arange-linspace-and-logspace-in-pytorch/
HARVARD
Super Kai (Kazuya Ito) | Sciencx Wednesday July 10, 2024 » arange(), linspace() and logspace() in PyTorch., viewed ,<https://www.scien.cx/2024/07/10/arange-linspace-and-logspace-in-pytorch/>
VANCOUVER
Super Kai (Kazuya Ito) | Sciencx - » arange(), linspace() and logspace() in PyTorch. [Internet]. [Accessed ]. Available from: https://www.scien.cx/2024/07/10/arange-linspace-and-logspace-in-pytorch/
CHICAGO
" » arange(), linspace() and logspace() in PyTorch." Super Kai (Kazuya Ito) | Sciencx - Accessed . https://www.scien.cx/2024/07/10/arange-linspace-and-logspace-in-pytorch/
IEEE
" » arange(), linspace() and logspace() in PyTorch." Super Kai (Kazuya Ito) | Sciencx [Online]. Available: https://www.scien.cx/2024/07/10/arange-linspace-and-logspace-in-pytorch/. [Accessed: ]
rf:citation
» arange(), linspace() and logspace() in PyTorch | Super Kai (Kazuya Ito) | Sciencx | https://www.scien.cx/2024/07/10/arange-linspace-and-logspace-in-pytorch/ |

Please log in to upload a file.



There are no updates yet.
Click the Upload button above to add an update.

You must be logged in to translate posts. Please log in or register.

Related Posts