1 tensor

import torch


print(torch.tensor([1, 2]))

  输出如下：

tensor([1, 2])

2 sparse_coo_tensor：以稀疏方式创建

  函数声明：torch.sparse_coo_tensor(indices, values, size=None, *, dtype=None, device=None, requires_grad=False) → Tensor

# 样本点的索引
indices = [[0, 1, 1], [2, 0, 2]]
# 索引对应的值
values = [5, 10, -3]
# 张量大小
size = [5, 4]
test = torch.sparse_coo_tensor(indices, values, size)
print(test)

  输出如下：

tensor(indices=tensor([[0, 1, 1],
                       [2, 0, 2]]),
       values=tensor([ 5, 10, -3]),
       size=(5, 4), nnz=3, layout=torch.sparse_coo)

3 as_tensor：转换为tensor，且保留已有梯度历史等

  函数声明：torch.as_tensor(data, dtype=None, device=None) → Tensor

l = [[0, 1, 1], [2, 0, 2]]
test = torch.as_tensor(l)
print(test)
# 会保留已有的梯度历史等
l = torch.tensor(l, dtype=torch.float16, requires_grad=True)
test = torch.as_tensor(l)
print(test)

  输出如下：

tensor([[0, 1, 1],
        [2, 0, 2]])
tensor([[0., 1., 1.],
        [2., 0., 2.]], dtype=torch.float16, requires_grad=True)

4 from_numpy：numpy转tensor

  函数声明：torch.from_numpy(ndarray) → Tensor

import torch
torch.manual_seed(1)

import numpy as np
a = np.random.randn(5, 4)
print(a)
b = torch.from_numpy(a)
print(b)

  输出如下：

[[-0.73184672  0.03196001  0.83596213  0.4532344 ]
 [-0.64156264  0.0558329   0.87383367  0.3905794 ]
 [-0.93415778 -0.06438401  2.88525277  0.30842341]
 [ 0.63993273  1.57506805 -0.90221034 -1.17684777]
 [ 0.21111362  2.12330942  1.10078778 -0.78174573]]
tensor([[-0.7318,  0.0320,  0.8360,  0.4532],
        [-0.6416,  0.0558,  0.8738,  0.3906],
        [-0.9342, -0.0644,  2.8853,  0.3084],
        [ 0.6399,  1.5751, -0.9022, -1.1768],
        [ 0.2111,  2.1233,  1.1008, -0.7817]], dtype=torch.float64)

5 zeros：创建全0的tensor

  函数声明：torch.zeros(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

a = torch.zeros([5, 4])
print(a)

  输出如下：

tensor([[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]])

6 zeros_like：创建与input同形的全0值tensor

  函数声明：torch.zeros_like(input, *, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format) → Tensor

a = torch.randn(3, 2)
print(a)
b = torch.zeros_like(a)
print(a)

  输出如下：

tensor([[ 0.6614,  0.2669],
        [ 0.0617,  0.6213],
        [-0.4519, -0.1661]])
tensor([[ 0.6614,  0.2669],
        [ 0.0617,  0.6213],
        [-0.4519, -0.1661]])

7 ones：创建全1值tensor

  函数声明：torch.ones(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

8 ones_like：创建与input同形的全1值tensor

  函数声明：torch.ones_like(input, *, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format) → Tensor

9 arange：创建给定范围与间隔的1维tensor

  函数声明：torch.arange(start=0, end, step=1, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

a = torch.arange(0.1, 0.2, 0.01)
print(a)

  输出如下：

tensor([0.1000, 0.1100, 0.1200, 0.1300, 0.1400, 0.1500, 0.1600, 0.1700, 0.1800,
        0.1900])

10 range：创建给定范围与间隔的1维tensor，多个值

  函数声明：torch.range(start=0, end, step=1, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

a = torch.range(0.1, 0.2, 0.01)
print(a)

  输出如下：

tensor([0.1000, 0.1100, 0.1200, 0.1300, 0.1400, 0.1500, 0.1600, 0.1700, 0.1800,
        0.1900, 0.2000])

11 linspace：给定步长划分给定区间

  函数声明：torch.linspace(start, end, steps, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

a = torch.linspace(0.1, 0.2, 7)
print(a)

  输出如下：

tensor([0.1000, 0.1167, 0.1333, 0.1500, 0.1667, 0.1833, 0.2000])

12 logspace：划分指数空间

  函数声明：torch.logspace(start, end, steps, base=10.0, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

a = torch.logspace(0.1, 0.2, 7, 3)
print(a)

  输出如下：

tensor([1.1161, 1.1367, 1.1578, 1.1791, 1.2009, 1.2231, 1.2457])

13 eye：创建对角二维tensor

  函数声明：torch.eye(n, m=None, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

a = torch.eye(4, 5)
print(a)

  输出如下：

tensor([[1., 0., 0., 0., 0.],
        [0., 1., 0., 0., 0.],
        [0., 0., 1., 0., 0.],
        [0., 0., 0., 1., 0.]])

14 empty：创建未初始化的的tensor

  函数声明：torch.empty(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False, memory_format=torch.contiguous_format) → Tensor

15 empty_like

  函数声明：torch.empty_like(input, *, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format) → Tensor

16 full：创建指定指定值指定大小的tensor

  函数声明：torch.full(size, fill_value, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

a = torch.full((2, 3), 3)
print(a)

  输出如下：

tensor([[3, 3, 3],
        [3, 3, 3]])

17 full_like

  函数声明：torch.full_like(input, fill_value, *, dtype=None, layout=torch.strided, device=None, requires_grad=False, memory_format=torch.preserve_format) → Tensor

18 complex：创建复数形tensor

  函数声明：torch.complex(real, imag, *, out=None) → Tensor

# 实部
real = torch.tensor([1, 2], dtype=torch.float32)
# 虚部
imag = torch.tensor([3, 4], dtype=torch.float32)
a = torch.complex(real, imag)
print(a)

  输出如下：

tensor([1.+3.j, 2.+4.j])

19 polar：创建极坐标复数形tensor

  函数声明：torch.polar(abs, angle, *, out=None) → Tensor

import numpy as np
# 绝对值
abs = torch.tensor([1, 2], dtype=torch.float64)
# 角度
angle = torch.tensor([np.pi / 2, 5 * np.pi / 4], dtype=torch.float64)
a = torch.polar(abs, angle)
print(a)

  输出如下：

tensor([ 6.1232e-17+1.0000j, -1.4142e+00-1.4142j], dtype=torch.complex128)

20 heaviside：创建给定输入下的阶跃tensor

  函数声明：torch.heaviside(input, values, *, out=None) → Tensor

input = torch.tensor([-1.5, 0, 2.0])
values = torch.tensor([0.5])
a = torch.heaviside(input, values)
print(a)
values = torch.tensor([1.2, -2.0, 3.5])
b = torch.heaviside(input, values)
print(b)

  输出如下：

tensor([0.0000, 0.5000, 1.0000])
tensor([ 0., -2.,  1.])