一、张量
本文是个人的学习笔记，内容主要参考了图书《python深度学习——基于pyTorch》、极客时间的课程《pyTorch深度学习实战》以及B站上“深度之眼”的课程《pyTorch框架基础》等。
1.1 概述
张量（Tensor）是一个多维数组，它是标量（0维张量）、向量（1维张量）、矩阵（2维张量）的高维扩展。
Tensor在torch.Tensor中，有以下几个基本属性：
- data: 存储了主要的数据
- grad: data的梯度
- grad_fn: 创建Tensor的Function，自动求导计算的依据
- requires_grad: 是否需要计算梯度
- is_leaf: 当前Tensor是否为计算图中的叶子节点
- dtype: 张量的数据类型，如
torch.FloatTensor，torch.cuda.FloatTensor等 - shape: 张量的形状
- device: 张量的位置，如GPU/CPU
非叶子节点的梯度会在计算梯度后被释放
1.2 张量的创建
1.2.1 直接创建
直接使用torch.tensor创建张量，默认在CPU上创建，定义为：
torch.tensor(data,
dtype=None,
device=None,
requires_grad=False,
pin_memory=False)
-
data: 数据，可以是ndarray、list、tuple、scalar等 -
dtype: 张量的数据类型，默认为torch.float32 -
device: 张量的位置，默认为torch.device('cpu') -
requires_grad: 是否需要计算梯度，默认为False -
pin_memory: 是否使用pinned memory，默认为False
除此以外，还可以使用
torch.Tensor进行张量的创建，torch.Tensor的创建和torch.tensor的创建基本相同，只是torch.Tensor是类，是默认张量类型torch.FloatTensor的别名；而torch.tensor()则是Python的函数。
import torch
t = torch.tensor([1,2,3])
print(t)
import numpy as np
arr = np.ones((3,3))
t = torch.tensor(arr, device='cuda', dtype=torch.int16)
print(t)
tensor([1, 2, 3], device='cuda:0')
tensor([[1, 1, 1],
[1, 1, 1],
[1, 1, 1]], device='cuda:0', dtype=torch.int16)
除此以外，还可以使用torch.Tensor的from_numpy方法创建张量，需要注意的是，使用from_numpy创建的Tensor和numpy的ndarray共享内存，修改一个，另一个也会改变：
import numpy as np
import torch
arr = np.array([[1,2,3],[4,5,6]])
t = torch.from_numpy(arr)
print('ndarray arr is {}'.format(arr))
print('Tensor t is {}'.format(t))
arr[1,2] = 10
print(t)
print('after modification arr is:\n {}'.format(arr))
print('After modify arr, t is:\n {}'.format(t))
ndarray arr is [[1 2 3]
[4 5 6]]
Tensor t is tensor([[1, 2, 3],
[4, 5, 6]], dtype=torch.int32)
tensor([[ 1, 2, 3],
[ 4, 5, 10]], dtype=torch.int32)
after modification arr is:
[[ 1 2 3]
[ 4 5 10]]
After modify arr, t is:
tensor([[ 1, 2, 3],
[ 4, 5, 10]], dtype=torch.int32)
1.2.2 依据数值创建
torch.zeros()
创建一个指定形状的张量，并初始化为0，其定义为：
torch.zeros(size,
out=None,
dtype=None,
layout=torch.strided,
device=None,
requires_grad=False)
-
size: 指定形状 -
out: 输出张量 -
dtype: 张量的数据类型，默认为torch.float32 -
layout: 张量的存储方式，默认为torch.strided -
device: 张量的位置，默认为torch.device('cpu')
import torch
Y = torch.ones([1])
X = torch.zeros((3, 3), out=Y)
print(X, Y, id(X), id(Y), id(X) == id(Y))
tensor([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]]) tensor([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]]) 2374969795552 2374969795552 True
可以看到X和Y是同一个内容
torch.ones_like()
依据内容形状创建全0张量，其定义为：
torch.ones_like(input,
out=None,
dtype=None,
layout=None,
device=None,
requires_grad=False)
torch.full()
依据内容创建全为特定值的张量，其定义为：
torch.full(size,
fill_value,
out=None,
dtype=None,
layout=torch.strided,
device=None,
requires_grad=False)
torch.arange()
创建一个等差数列的张量（半开半闭区间，即[start, end)），其定义为：
torch.arange(start=0,
end,
step=1,
out=None,
dtype=None,
layout=torch.strided,
device=None,
requires_grad=False)
torch.linspace()
创建一个等差张量，与arange的区别在于，该函数在一定数值范围内(闭区间)构建一个等差的张量，而不需要指定间隔的大小，其定义为：
torch.linspace(start,
end,
steps=100,
out=None,
dtype=None,
layout=torch.strided,
device=None,
requires_grad=False)
此处需要注意的是第三个参数step，该参数表示的是最后生成的张量的长度，而不是数列的间隔，因此实际的间隔为
import torch
torch.linspace(0, 10, 5)
tensor([ 0.0000, 2.5000, 5.0000, 7.5000, 10.0000])
torch.logspace()
创建一个对数等比数列的张量，其定义为：
torch.logspace(start,
end,
steps=100,
base=10.0,
out=None,
dtype=None,
layout=torch.strided,
device=None,
requires_grad=False)
其中，
-
base: 表示对数数列的底数，默认为10 -
step: 表示最后生成的张量的长度，而不是数列的间隔，因此实际的间隔为
1.2.3 创建随机张量
torch.normal()
创建一个正态分布的张量，其定义为：
torch.normal(mean, std, out=None)
torch.normal(mean, std, size, out=None)
需要注意的是对于
normal()函数而言，当mean和std均为标量时，必须指定size参数，否则会报错
import torch
# mean为张量，std为张量
mean = torch.arange(1, 5, dtype=torch.float)
std = torch.arange(1, 5, dtype=torch.float)
t_normal = torch.normal(mean, std)
print('mean is {}\nstd is {}'.format(mean, std))
print('t_normal is {}'.format(t_normal))
# mean为标量，std为标量
t_normal = torch.normal(0.0, 1.0, size=(1,))
print('t_normal is {}'.format(t_normal))
# mean为张量，std为标量
mean = torch.arange(1, 5, dtype=torch.float)
std = 1
t_normal = torch.normal(mean, std)
print("mean is {}\nstd is {}".format(mean, std))
print('t_normal is {}'.format(t_normal))
mean is tensor([1., 2., 3., 4.])
std is tensor([1., 2., 3., 4.])
t_normal is tensor([0.1857, 1.8819, 5.5086, 6.1349])
t_normal is tensor([1.3543])
mean is tensor([1., 2., 3., 4.])
std is 1
t_normal is tensor([2.2058, 0.9800, 3.6500, 3.6093])
torch.randn()
创建一个标准正态分布的张量，其定义为：
torch.randn(size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)
-
size: 指定张量的形状
torch.rand()和torch.rand_like()
在区间创建一个均匀分布的张量，其定义为：
torch.rand(size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)
torch.rand_like(input, dtype=None, layout=None, device=None, requires_grad=False, memory_format=None)
torch.randint()和torch.randint_like()
在一个区间上，创建一个均匀分布的整数张量，其定义为：
torch.randint(low=0,
high,
size,
out=None,
dtype=None,
layout=torch.strided,
device=None,
requires_grad=False)
参考官方文档：https://pytorch.org/docs/stable/generated/torch.randint.html#torch-randint
torch.randint_like(input,
low=0,
high=None,
size=None,
out=None,
dtype=None,
layout=None,
device=None,
requires_grad=False,
memory_format=torch.preserve_format)
参考官方文档：https://pytorch.org/docs/stable/generated/torch.randint_like.html#torch-randint-like
torch.randperm()
创建一个随机排列的整数张量，常常用来生成一个随机索引，其定义为：
torch.randperm(n,
out=None,
dtype=torch.int64,
layout=torch.strided,
device=None,
requires_grad=False)
torch.bernoulli()
以input的值作为概率，生成一个服从伯努利分布的张量，其定义为：
torch.bernoulli(input,
*
generator=None,
out=None)
import torch
t = torch.bernoulli(torch.tensor([0.1, 0.2, 0.3, 0.4, 0.5]))
t
tensor([0., 1., 0., 1., 1.])
1.3 张量的操作
1.3.1 张量的拼接
torch.cat()
将输入的张量按维度dim拼接起来，其定义为：
torch.cat(tensors, dim=0, out=None)
- tensors：输入的张量列表
- dim：在哪个维度上拼接，默认为0
dim可以理解为：操作后会发生变化的维度
torch.stack()
将输入的张量在新创建的维度dim拼接起来，其定义为：
torch.stack(tensors, dim=0, out=None)
- tensors：输入的张量列表
- dim：在哪个维度上增加，默认为0
# cat的操作
import torch
t = torch.arange(1,7)
t = torch.reshape(t, (2,3))
t_0 = torch.cat([t, t], dim=0)
t_1 = torch.cat([t, t], dim=1)
print('tensor t is {}'.format(t))
print(t.shape)
print('在dim=0上执行操作cat的结果为{}'.format(t_0))
print(t_0.shape)
print('在dim=1上执行操作cat的结果为{}'.format(t_1))
print(t_1.shape)
tensor t is tensor([[1, 2, 3],
[4, 5, 6]])
torch.Size([2, 3])
在dim=0上执行操作cat的结果为tensor([[1, 2, 3],
[4, 5, 6],
[1, 2, 3],
[4, 5, 6]])
torch.Size([4, 3])
在dim=1上执行操作cat的结果为tensor([[1, 2, 3, 1, 2, 3],
[4, 5, 6, 4, 5, 6]])
torch.Size([2, 6])
# stack的操作
t_stack_0 = torch.stack([t, t], dim=0)
t_stack_1 = torch.stack([t, t], dim=2)
print(t_stack_0)
print(t_stack_0.shape)
print(t_stack_1)
print(t_stack_1.shape)
tensor([[[1, 2, 3],
[4, 5, 6]],
[[1, 2, 3],
[4, 5, 6]]])
torch.Size([2, 2, 3])
tensor([[[1, 1],
[2, 2],
[3, 3]],
[[4, 4],
[5, 5],
[6, 6]]])
torch.Size([2, 3, 2])
1.3.2 张量的切分
torch.chunk()
将输入的张量在dim维度上按照chunks个大小切分，其定义为：
torch.chunk(input, chunks, dim=0)
-
input：输入的张量 -
chunks：切分的份数，必须为整数 -
dim：在哪个维度上切分，默认为0
若不能整除，
chunk函数是先做除法，然后再向上取整得到每组的数量。例如原始tensor中有10个元素时，当chunks=3时, 10/3=3.3333, 向上取整为4，所以最后得到每组张量有4个元素，最后剩下的两个元素自动归为1组。
import torch
A=torch.arange(1,11)
B = torch.chunk(A, 2, 0)
print(B)
# 不能整除的情况
B = torch.chunk(A, 3, 0)
print(B)
(tensor([1, 2, 3, 4, 5]), tensor([ 6, 7, 8, 9, 10]))
(tensor([1, 2, 3, 4]), tensor([5, 6, 7, 8]), tensor([ 9, 10]))
torch.split()
将输入的张量在dim维度上按照split_size的大小切分，其定义为：
torch.split(tensor, split_size_or_sections, dim=0)
-
tensor：输入的张量 -
split_size_or_sections：切分的份数，若为整数，则会在指定维度上将整个张量切分为split_size_or_sections大小（不能整除时，最后剩下的为1组）；若为list，则按照list中元素的数量来切分 -
dim：在哪个维度上切分，默认为0
import torch
A = torch.rand(4, 4)
print('原始tensor为\n{}'.format(A))
print('1.split_size_or_sections为整数，且可以整除时:')
B = torch.split(A, 2, 0)
print(B)
print('2.split_size_or_sections为整数，且不可以整除时:')
B = torch.split(A, 3, 0)
print(B)
print('3.split_size_or_sections为列表时:')
B = torch.split(A, [1, 3], 0)
print(B)
原始tensor为
tensor([[0.3747, 0.0479, 0.1082, 0.7263],
[0.8332, 0.2020, 0.7699, 0.0615],
[0.8753, 0.0584, 0.9294, 0.3031],
[0.6463, 0.2581, 0.3250, 0.5398]])
1.split_size_or_sections为整数，且可以整除时:
(tensor([[0.3747, 0.0479, 0.1082, 0.7263],
[0.8332, 0.2020, 0.7699, 0.0615]]), tensor([[0.8753, 0.0584, 0.9294, 0.3031],
[0.6463, 0.2581, 0.3250, 0.5398]]))
2.split_size_or_sections为整数，且不可以整除时:
(tensor([[0.3747, 0.0479, 0.1082, 0.7263],
[0.8332, 0.2020, 0.7699, 0.0615],
[0.8753, 0.0584, 0.9294, 0.3031]]), tensor([[0.6463, 0.2581, 0.3250, 0.5398]]))
3.split_size_or_sections为列表时:
(tensor([[0.3747, 0.0479, 0.1082, 0.7263]]), tensor([[0.8332, 0.2020, 0.7699, 0.0615],
[0.8753, 0.0584, 0.9294, 0.3031],
[0.6463, 0.2581, 0.3250, 0.5398]]))
1.3.3 张量的索引
torch.index_select()
将输入的张量在dim维度上按照index索引进行选择，其定义为：
torch.index_select(
input,
dim,
index,
out)
-
input：输入的张量 -
dim：在哪个维度上选择，默认为0 -
index：索引，数据类型为tensor.long
import torch
t = torch.arange(1, 10).view((3, 3 ))
print(t)
idx = torch.tensor([0, 2], dtype=torch.long)
t_select = torch.index_select(t, dim=0, index=idx)
print(t_select)
tensor([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
tensor([[1, 2, 3],
[7, 8, 9]])
tensor.masked_select()
将输入的张量在dim维度上按照mask索引进行选择，其定义为：
torch.masked_select(
input,
mask,
out=None)
-
input：输入的张量 -
mask：索引，数据类型为tensor.bool的列表，大小与input相同
返回值为满足条件的1维张量
import torch
t = torch.arange(1, 10).view((3, 3 ))
mask = t.ge(5)
t_select = t.masked_select(mask)
print('mask is: \n{}'.format(mask))
print(t_select)
# 也可以简化为如下形式：
t_select = torch.masked_select(t, t>=5)
print(t_select)
mask is:
tensor([[False, False, False],
[False, True, True],
[ True, True, True]])
tensor([5, 6, 7, 8, 9])
tensor([5, 6, 7, 8, 9])
1.3.4 张量变换
torch.reshape()
将输入的张量按照shape重新排列，其定义为：
torch.reshape(input, shape)
-
input要变换的张量 -
shape新的形状，如果一个维度为-1，则这个维度会自动计算
注意：当张量在内存中是连续的时候，新得到的张量与
input共享内存。
import torch
t = torch.randperm(8)
print('原始数据t为：\n{}'.format(t))
t_reshape = torch.reshape(t, (-1, 4))
print('reshape得到的数据为：\n{}'.format(t_reshape))
# 共享内存验证
t[0] = 1024
print('修改了t的第一个元素为1024后，t的值变为：\n{}'.format(t))
print('reshape得到的数据变为：\n{}'.format(t_reshape))
原始数据t为：
tensor([4, 5, 0, 2, 7, 3, 1, 6])
reshape得到的数据为：
tensor([[4, 5, 0, 2],
[7, 3, 1, 6]])
修改了t的第一个元素为1024后，t的值变为：
tensor([1024, 5, 0, 2, 7, 3, 1, 6])
reshape得到的数据变为：
tensor([[1024, 5, 0, 2],
[ 7, 3, 1, 6]])
torch.transpose()
将输入的张量按照dim0和dim1进行转置，其定义为：
torch.transpose(input, dim0, dim1)
t.transpose(dim0, dim1)
torch.t()
2维张量的转置，相当于torch.transpose(input, 0, 1)
import torch
t = torch.rand((2,3,4))
# 也可以写成t_tranpose = torch.transpose(t, 0, 1)
t_transpose = t.transpose(dim0=0, dim1=1)
print('t的转置为：\n{}'.format(t_transpose.shape))
t的转置为：
torch.Size([3, 2, 4])
torch.squeeze()
若dim为None，则将输入的张量中所有维度为1的维度删除；若指定了dim，且指定维度的长度为1，则移除该维度，其定义为：
torch.squeeze(input,
dim=None,
out=None)
torch.unsqueeze()
将输入的张量中指定维度增加一个维度，其定义为：
torch.unsqueeze(input,
dim,
out=None)
依据dim扩展维度
import torch
t = torch.rand((2,1,4))
t_squeeze = torch.squeeze(t)
print('t的形状为：\n{}'.format(t.shape))
print('squeeze后t的形状为：\n{}'.format(t_squeeze.shape))
t_unsqueeze = torch.unsqueeze(t, 3)
print('unsqueeze后的形状为：\n{}'.format(t_unsqueeze.shape))
t的形状为：
torch.Size([2, 1, 4])
squeeze后t的形状为：
torch.Size([2, 4])
unsqueeze后的形状为：
torch.Size([2, 1, 4, 1])
1.4 张量的计算
1.4.1 加法
torch.add()
对输入的张量进行加法操作（先乘后加），其定义为：
torch.add(input,
other,
*,
alpha=1,
out=None)
-
input：第一个的张量 -
alpha：加法操作的系数，默认为1 -
other：第二个的张量
整个运算完成的操作公式为：
import torch
t1 = torch.ones((3,3)) * 2
t2 = torch.ones((3,3))
print(torch.add(t1, t2, alpha=10))
tensor([[12., 12., 12.],
[12., 12., 12.],
[12., 12., 12.]])
