logspace() in PyTorch
Tags: pytorch, logspace, tensor, function
Published: 2024-07-10 15:24:30

*[My post](https://dev.to/hyperkai/arange-and-linspace-in-pytorch-3ak7) explains [arange()](https://pytorch.org/docs/stable/generated/torch.arange.html) and [linspace()](https://pytorch.org/docs/stable/generated/torch.linspace.html).

[logspace()](https://pytorch.org/docs/stable/generated/torch.logspace.html) can create the 1D tensor of the zero or more integers, floating-point numbers or complex numbers evenly spaced between <code>base<sup>start</sup></code> and <code>base<sup>end</sup></code>(<code>base<sup>start</sup></code><=x<=<code>base<sup>end</sup></code>) as shown below:

*Memos:
- `logspace()` can be used with [torch](https://pytorch.org/docs/stable/torch.html) 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](https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype)):
  *Memos:
  - If `dtype` is not given, `dtype` is inferred from `start`, `end` or `step` or `dtype` of [set_default_dtype()](https://pytorch.org/docs/stable/generated/torch.set_default_dtype.html) 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](https://dev.to/hyperkai/set-dtype-with-dtype-argument-functions-and-get-it-in-pytorch-13h2) explains `dtype` argument.
- There is `device` argument with `torch`(Optional-Type:`str`, `int` or [device()](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device)):
  *Memos:
  - `device=` must be used.
  - [My post](https://dev.to/hyperkai/set-device-with-device-argument-functions-and-get-it-in-pytorch-1o2p) explains `device` argument.
- There is `requires_grad` argument with `torch`(Optional-Type:`bool`):
  *Memos:
  - `requires_grad=` must be used.
  - [My post](https://dev.to/hyperkai/set-requiresgrad-with-requiresgrad-argument-functions-and-get-it-in-pytorch-39c3) explains `requires_grad` argument.
- There is `out` argument with `torch`(Optional-Type:`tensor`):
  *Memos:
  - `out=` must be used.
  - [My post](https://dev.to/hyperkai/set-out-with-out-argument-functions-pytorch-3ee) explains `out` argument.

```python
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.])
```