介绍
在PyTorch中，torch.Tensor是存储和变换数据的主要工具。它是构建深度学习模型的基本数据结构，可以包含标量、向量、矩阵等。Tensor不仅支持多种数据类型，还可以在CPU和GPU之间无缝移动，这使得它在进行大规模并行计算时非常高效。Tensor是PyTorch实现机器学习算法的核心，因为它提供了必要的数据结构来存储和操作数据。
安装
1
2
# 安装torch：基础包; torchvision：视觉； torchaudio：音频；
pip install torch torchvision torchaudio
导入
1
2
3
import torch
torch.__version__
1
'2.5.1+cu124'
创建
构造函数创建张量
1
2
3
4
# 指定形状
a = torch.Tensor(2, 3)
print(a.dtype)
print(a)
1
2
3
torch.float32
tensor([[ 4.0255e-41, 0.0000e+00, 0.0000e+00],
[ 0.0000e+00, -2.9190e+24, 4.2591e-41]])
数据直接创建张量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 创建出来的是0维张量(也就是一个标量)
b = torch.tensor(10)
print(b.dtype)
print(b)
# 用list列表
c = torch.tensor([[1, 2, 3], [2, 3, 4]])
print(c)
# 指定数据类型
d = torch.tensor([[1, 2, 3], [2, 3, 4]], dtype=torch.float32)
print(d.dtype)
print(d)
# 包含浮点数则默认推断为torch.float32
e = torch.tensor([[1, 2.0, 3], [2, 3, 4]])
print(e.dtype)
print(e)
1
2
3
4
5
6
7
8
9
10
torch.int64
tensor(10)
tensor([[1, 2, 3],
[2, 3, 4]])
torch.float32
tensor([[1., 2., 3.],
[2., 3., 4.]])
torch.float32
tensor([[1., 2., 3.],
[2., 3., 4.]])
随机创建张量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 创建在 [0.0, 1.0) 区间内均匀分布的一组随机数张量,形状(2,3)
a = torch.rand((2, 3))
print(a)
# 创建在 [0, 9) 区间内均匀分布的一组随机数整数张量，形状(2,3)
b = torch.randint(0, 9, (2, 3))
print(b)
# 创建符合 标准正态分布（均值为0，方差为1）的随机数张量，形状(3,6)
c = torch.randn((3, 6))
print(c)
# 创建在 [0.0, 1.0) 区间内均匀分布的一组随机数张量，其形状与a相同。
d = torch.rand_like(a)
print(d)
# 创建在 [0, 9) 区间内均匀分布的一组随机数整数张量，其形状与c相同
e = torch.randint_like(b, 9)
print(e)
# 创建符合 标准正态分布（均值为0，方差为1）的随机数张量，其形状与输入的c相同。
f = torch.randn_like(c)
print(f)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
tensor([[0.9245, 0.7784, 0.1347],
[0.5307, 0.5987, 0.0651]])
tensor([[7, 6, 4],
[8, 7, 4]])
tensor([[-0.6282, 0.9156, -0.2587, -1.0044, -0.0231, 0.2900],
[ 0.4500, 0.0767, 0.8181, -0.5696, 1.8729, -0.3976],
[-1.9062, 0.7666, 0.5882, -0.5821, -0.3165, 0.1443]])
tensor([[0.7203, 0.6869, 0.9923],
[0.1351, 0.2959, 0.6648]])
tensor([[7, 3, 8],
[2, 4, 7]])
tensor([[ 1.6523, 0.4005, 1.1945, 0.0073, 0.3106, -0.1109],
[ 1.6119, -0.6008, 1.0225, -2.1142, 0.5692, 0.1690],
[-1.9736, 0.0629, 0.3265, 1.0271, -0.2424, -0.4625]])
规则创建张量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 在 [0, 10) 范围内，以 2 为步长创建一维张量
a = torch.arange(0, 10, 2)
print(a)
# 在 [0, 10] 范围内，构造均匀分布的 等间距，有 5 个元素的一维张量。
b = torch.linspace(0, 10, 5)
print(b)
# 生成一个大小为 5 的一维张量, 元素值为 2^x，其中 x 是 torch.linspace() 产生的序列值。
c = torch.logspace(0, 4, 5, 2)
print(c)
# 生成一个线性张量
d = torch.linspace(0, 4, 5)
print(d)
1
2
3
4
tensor([0, 2, 4, 6, 8])
tensor([ 0.0000, 2.5000, 5.0000, 7.5000, 10.0000])
tensor([ 1., 2., 4., 8., 16.])
tensor([0., 1., 2., 3., 4.])
创建特殊张量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 创建全0张量
a = torch.zeros(3, 3)
print(a)
# 创建全1张量
b = torch.ones(3, 4)
print(b)
# 创建单位张量
c = torch.eye(4, 4)
print(c)
# 根据指定形状，填充指定数值
d = torch.full([2, 3], 6)
print(d)
# 创建一个未初始化的Tensor
e = torch.empty(5,3)
print(e)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
tensor([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]])
tensor([[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]])
tensor([[1., 0., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.]])
tensor([[6, 6, 6],
[6, 6, 6]])
tensor([[1.0019e-34, 0.0000e+00, 0.0000e+00],
[0.0000e+00, 0.0000e+00, 0.0000e+00],
[0.0000e+00, 0.0000e+00, 2.8026e-45],
[0.0000e+00, 1.1210e-44, 0.0000e+00],
[1.4013e-45, 0.0000e+00, 0.0000e+00]])
创建复数张量
1
2
3
4
5
6
# 复数张量
real = torch.tensor([1, 2], dtype=torch.float32)
imag = torch.tensor([3, 4], dtype=torch.float32)
x = torch.complex(real, imag)
print(x)
print(x.dtype)
1
2
tensor([1.+3.j, 2.+4.j])
torch.complex64
其他
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import numpy
# 从文件创建
t = torch.randn(2, 5, dtype=torch.float64)
t.numpy().tofile('storage.pt')
t_mapped = torch.from_file('storage.pt', shared=False, size=10, dtype=torch.float64)
print(t_mapped)
# 从numpy创建
a = numpy.array([1, 2, 3])
b = torch.from_numpy(a)
print(b)
# 外部库数据创建
import torch.utils.dlpack
t = torch.arange(4)
t2 = torch.from_dlpack(t)
t2[:2] = -1
print(t2)
print(t)
capsule = torch.utils.dlpack.to_dlpack(t)
print(capsule)
t3 = torch.from_dlpack(capsule)
print(t3)
print(t2)
print(t)
1
2
3
4
5
6
7
8
9
tensor([ 0.7259, 0.7342, 2.2240, 0.5605, -1.1181, -0.8292, -0.6190, -1.3916,
0.0555, -0.8264], dtype=torch.float64)
tensor([1, 2, 3])
tensor([-1, -1, 2, 3])
tensor([-1, -1, 2, 3])
<capsule object "dltensor" at 0x76bae8011bf0>
tensor([-1, -1, 2, 3])
tensor([-1, -1, 2, 3])
tensor([-1, -1, 2, 3])
属性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 是否开启梯度（requires_grad）
x = torch.zeros(1, requires_grad=True)
# with torch.no_grad():
y = x * 2
print(y.requires_grad)
# 梯度值
z = torch.tensor([[1., -1.], [1., 1.]], requires_grad=True)
out = z.pow(2).sum()
out.backward()
print(z.grad)
# 转置
t = torch.tensor([[1,2,3],[4,5,6]])
print(t)
print(t.T)
1
2
3
4
5
6
7
8
True
tensor([[ 2., -2.],
[ 2., 2.]])
tensor([[1, 2, 3],
[4, 5, 6]])
tensor([[1, 4],
[2, 5],
[3, 6]])
设备
torch.device 是 PyTorch 中用于表示计算设备（如CPU或GPU）的类。它允许你在代码中指定你希望在哪个设备上执行张量和模型操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# 设备
# 创建第一个GPU设备对象,第一张显卡
torch.device('cuda:0')
# 创建一个CPU设备对象
torch.device('cpu')
# 创建第一个GPU设备对象
torch.device('cuda')
# 创建一个CPU设备对象
cpu_device = torch.device("cpu")
# 创建第一个GPU设备对象
gpu_device = torch.device("cuda:0")
# 创建一个CPU张量
tensor_cpu = torch.tensor([1, 2, 3])
# 将张量移动到CPU上
tensor_cpu = tensor_cpu.to(cpu_device)
# 创建一个模型
# model = MyModel()
# 移到GPU上
# model = model.to(gpu_device)