1.3 张量操作与线性回归

张量的操作

拼接

torch.cat()

1
torch.cat(tensors, dim=0, out=None)
Copied!
功能:将张量按照 dim 维度进行拼接
  • tensors: 张量序列
  • dim: 要拼接的维度
代码示例:
1
t = torch.ones((2, 3))
2
t_0 = torch.cat([t, t], dim=0)
3
t_1 = torch.cat([t, t], dim=1)
4
print("t_0:{} shape:{}\nt_1:{} shape:{}".format(t_0, t_0.shape, t_1, t_1.shape))
Copied!
输出是:
1
t_0:tensor([[1., 1., 1.],
2
[1., 1., 1.],
3
[1., 1., 1.],
4
[1., 1., 1.]]) shape:torch.Size([4, 3])
5
t_1:tensor([[1., 1., 1., 1., 1., 1.],
6
[1., 1., 1., 1., 1., 1.]]) shape:torch.Size([2, 6])
Copied!

torch.stack()

1
torch.stack(tensors, dim=0, out=None)
Copied!
功能:将张量在新创建的 dim 维度上进行拼接
  • tensors: 张量序列
  • dim: 要拼接的维度
代码示例:
1
t = torch.ones((2, 3))
2
# dim =2
3
t_stack = torch.stack([t, t, t], dim=2)
4
print("\nt_stack.shape:{}".format(t_stack.shape))
5
# dim =0
6
t_stack = torch.stack([t, t, t], dim=0)
7
print("\nt_stack.shape:{}".format(t_stack.shape))
Copied!
输出为:
1
t_stack.shape:torch.Size([2, 3, 3])
2
t_stack.shape:torch.Size([3, 2, 3])
Copied!
第一次指定拼接的维度 dim =2,结果的维度是 [2, 3, 3]。后面指定拼接的维度 dim =0,由于原来的 tensor 已经有了维度 0,因此会把tensor 往后移动一个维度变为 [1,2,3],再拼接变为 [3,2,3]。

切分

torch.chunk()

1
torch.chunk(input, chunks, dim=0)
Copied!
功能:将张量按照维度 dim 进行平均切分。若不能整除,则最后一份张量小于其他张量。
  • input: 要切分的张量
  • chunks: 要切分的份数
  • dim: 要切分的维度
代码示例:
1
a = torch.ones((2, 7)) # 7
2
list_of_tensors = torch.chunk(a, dim=1, chunks=3) # 3
3
for idx, t in enumerate(list_of_tensors):
4
print("第{}个张量:{}, shape is {}".format(idx+1, t, t.shape))
Copied!
输出为:
1
第1个张量:tensor([[1., 1., 1.],
2
[1., 1., 1.]]), shape is torch.Size([2, 3])
3
第2个张量:tensor([[1., 1., 1.],
4
[1., 1., 1.]]), shape is torch.Size([2, 3])
5
第3个张量:tensor([[1.],
6
[1.]]), shape is torch.Size([2, 1])
Copied!
由于 7 不能整除 3,7/3 再向上取整是 3,因此前两个维度是 [2, 3],所以最后一个切分的张量维度是 [2,1]。

torch.split()

1
torch.split(tensor, split_size_or_sections, dim=0)
Copied!
功能:将张量按照维度 dim 进行平均切分。可以指定每一个分量的切分长度。
  • tensor: 要切分的张量
  • split_size_or_sections: 为 int 时,表示每一份的长度,如果不能被整除,则最后一份张量小于其他张量;为 list 时,按照 list 元素作为每一个分量的长度切分。如果 list 元素之和不等于切分维度 (dim) 的值,就会报错。
  • dim: 要切分的维度
代码示例:
1
t = torch.ones((2, 5))
2
list_of_tensors = torch.split(t, [2, 1, 2], dim=1)
3
for idx, t in enumerate(list_of_tensors):
4
print("第{}个张量:{}, shape is {}".format(idx+1, t, t.shape))
Copied!
结果为:
1
第1个张量:tensor([[1., 1.],
2
[1., 1.]]), shape is torch.Size([2, 2])
3
第2个张量:tensor([[1.],
4
[1.]]), shape is torch.Size([2, 1])
5
第3个张量:tensor([[1., 1.],
6
[1., 1.]]), shape is torch.Size([2, 2])
Copied!

索引

torch.index_select()

1
torch.index_select(input, dim, index, out=None)
Copied!
功能:在维度 dim 上,按照 index 索引取出数据拼接为张量返回。
  • input: 要索引的张量
  • dim: 要索引的维度
  • index: 要索引数据的序号
代码示例:
1
# 创建均匀分布
2
t = torch.randint(0, 9, size=(3, 3))
3
# 注意 idx 的 dtype 不能指定为 torch.float
4
idx = torch.tensor([0, 2], dtype=torch.long)
5
# 取出第 0 行和第 2 行
6
t_select = torch.index_select(t, dim=0, index=idx)
7
print("t:\n{}\nt_select:\n{}".format(t, t_select))
Copied!
输出为:
1
t:
2
tensor([[4, 5, 0],
3
[5, 7, 1],
4
[2, 5, 8]])
5
t_select:
6
tensor([[4, 5, 0],
7
[2, 5, 8]])
Copied!

torch.mask_select()

1
torch.masked_select(input, mask, out=None)
Copied!
功能:按照 mask 中的 True 进行索引拼接得到一维张量返回。
  • 要索引的张量
  • mask: 与 input 同形状的布尔类型张量
代码示例:
1
t = torch.randint(0, 9, size=(3, 3))
2
mask = t.le(5) # ge is mean greater than or equal/ gt: greater than le lt
3
# 取出大于 5 的数
4
t_select = torch.masked_select(t, mask)
5
print("t:\n{}\nmask:\n{}\nt_select:\n{} ".format(t, mask, t_select))
Copied!
结果为:
1
t:
2
tensor([[4, 5, 0],
3
[5, 7, 1],
4
[2, 5, 8]])
5
mask:
6
tensor([[ True, True, True],
7
[ True, False, True],
8
[ True, True, False]])
9
t_select:
10
tensor([4, 5, 0, 5, 1, 2, 5])
Copied!
最后返回的是一维张量。

变换

torch.reshape()

1
torch.reshape(input, shape)
Copied!
功能:变换张量的形状。当张量在内存中是连续时,返回的张量和原来的张量共享数据内存,改变一个变量时,另一个变量也会被改变。
  • input: 要变换的张量
  • shape: 新张量的形状
代码示例:
1
# 生成 0 到 8 的随机排列
2
t = torch.randperm(8)
3
# -1 表示这个维度是根据其他维度计算得出的
4
t_reshape = torch.reshape(t, (-1, 2, 2))
5
print("t:{}\nt_reshape:\n{}".format(t, t_reshape))
Copied!
结果为:
1
t:tensor([5, 4, 2, 6, 7, 3, 1, 0])
2
t_reshape:
3
tensor([[[5, 4],
4
[2, 6]],
5
6
[[7, 3],
7
[1, 0]]])
Copied!
在上面代码的基础上,修改原来的张量的一个元素,新张量也会被改变。
代码示例:
1
# 修改张量 t 的第 0 个元素,张量 t_reshape 也会被改变
2
t[0] = 1024
3
print("t:{}\nt_reshape:\n{}".format(t, t_reshape))
4
print("t.data 内存地址:{}".format(id(t.data)))
5
print("t_reshape.data 内存地址:{}".format(id(t_reshape.data)))
Copied!
结果为:
1
t:tensor([1024, 4, 2, 6, 7, 3, 1, 0])
2
t_reshape:
3
tensor([[[1024, 4],
4
[ 2, 6]],
5
6
[[ 7, 3],
7
[ 1, 0]]])
8
t.data 内存地址:2636803119936
9
t_reshape.data 内存地址:2636803119792
Copied!

torch.transpose()

1
torch.transpose(input, dim0, dim1)
Copied!
功能:交换张量的两个维度。常用于图像的变换,比如把c*h*w变换为h*w*c
  • input: 要交换的变量
  • dim0: 要交换的第一个维度
  • dim1: 要交换的第二个维度
代码示例:
1
#把 c * h * w 变换为 h * w * c
2
t = torch.rand((2, 3, 4))
3
t_transpose = torch.transpose(t, dim0=1, dim1=2) # c*h*w h*w*c
4
print("t shape:{}\nt_transpose shape: {}".format(t.shape, t_transpose.shape))
Copied!
结果为:
1
t shape:torch.Size([2, 3, 4])
2
t_transpose shape: torch.Size([2, 4, 3])
Copied!

torch.t()

功能:2 维张量转置,对于 2 维矩阵而言,等价于torch.transpose(input, 0, 1)

torch.squeeze()

1
torch.squeeze(input, dim=None, out=None)
Copied!
功能:压缩长度为 1 的维度。
  • dim: 若为 None,则移除所有长度为 1 的维度;若指定维度,则当且仅当该维度长度为 1 时可以移除。
代码示例:
1
# 维度 0 和 3 的长度是 1
2
t = torch.rand((1, 2, 3, 1))
3
# 可以移除维度 0 和 3
4
t_sq = torch.squeeze(t)
5
# 可以移除维度 0
6
t_0 = torch.squeeze(t, dim=0)
7
# 不能移除 1
8
t_1 = torch.squeeze(t, dim=1)
9
print("t.shape: {}".format(t.shape))
10
print("t_sq.shape: {}".format(t_sq.shape))
11
print("t_0.shape: {}".format(t_0.shape))
12
print("t_1.shape: {}".format(t_1.shape))
Copied!
结果为:
1
t.shape: torch.Size([1, 2, 3, 1])
2
t_sq.shape: torch.Size([2, 3])
3
t_0.shape: torch.Size([2, 3, 1])
4
t_1.shape: torch.Size([1, 2, 3, 1])
Copied!

torch.unsqueeze()

1
torch.unsqueeze(input, dim)
Copied!
功能:根据 dim 扩展维度,长度为 1。

张量的数学运算

主要分为 3 类:加减乘除,对数,指数,幂函数 和三角函数。
这里介绍一下常用的几种方法。

torch.add()

1
torch.add(input, other, out=None)
2
torch.add(input, other, *, alpha=1, out=None)
Copied!
功能:逐元素计算 input + alpha * other。因为在深度学习中经常用到先乘后加的操作。
  • input: 第一个张量
  • alpha: 乘项因子
  • other: 第二个张量

torch.addcdiv()

1
torch.addcdiv(input, tensor1, tensor2, *, value=1, out=None)
Copied!
计算公式为:out ${i}=\operatorname{input}{i}+$ value $\times \frac{\text { tensor } 1{i}}{\text { tensor } 2{i}}$

torch.addcmul()

1
torch.addcmul(input, tensor1, tensor2, *, value=1, out=None)
Copied!
计算公式为:out ${i}=$ input ${i}+$ value $\times$ tensor $1{i} \times$ tensor $2{i}$

线性回归

线性回归是分析一个变量 ($y$) 与另外一 (多) 个变量 ($x$) 之间的关系的方法。一般可以写成 $y=wx+b$。线性回归的目的就是求解参数$w, b$。
线性回归的求解可以分为 3 步:
  1. 1.
    确定模型:$y=wx+b$
  2. 2.
    选择损失函数,一般使用均方误差 MSE:$\frac{1}{m} \sum{i=1}^{m}\left(y{i}-\hat{y}{i}\right)^{2}$。其中 $ \hat{y}{i} $ 是预测值,$y$ 是真实值。
  3. 3.
    使用梯度下降法求解梯度 (其中 $lr$ 是学习率),并更新参数:
    • $w = w - lr * w.grad$
    • $b = b - lr * b.grad$
代码如下:
1
import torch
2
import matplotlib.pyplot as plt
3
torch.manual_seed(10)
4
5
lr = 0.05 # 学习率
6
7
# 创建训练数据
8
x = torch.rand(20, 1) * 10 # x data (tensor), shape=(20, 1)
9
# torch.randn(20, 1) 用于添加噪声
10
y = 2*x + (5 + torch.randn(20, 1)) # y data (tensor), shape=(20, 1)
11
12
# 构建线性回归参数
13
w = torch.randn((1), requires_grad=True) # 设置梯度求解为 true
14
b = torch.zeros((1), requires_grad=True) # 设置梯度求解为 true
15
16
# 迭代训练 1000 次
17
for iteration in range(1000):
18
19
# 前向传播,计算预测值
20
wx = torch.mul(w, x)
21
y_pred = torch.add(wx, b)
22
23
# 计算 MSE loss
24
loss = (0.5 * (y - y_pred) ** 2).mean()
25
26
# 反向传播
27
loss.backward()
28
29
# 更新参数
30
b.data.sub_(lr * b.grad)
31
w.data.sub_(lr * w.grad)
32
33
# 每次更新参数之后,都要清零张量的梯度
34
w.grad.zero_()
35
b.grad.zero_()
36
37
# 绘图,每隔 20 次重新绘制直线
38
if iteration % 20 == 0:
39
40
plt.scatter(x.data.numpy(), y.data.numpy())
41
plt.plot(x.data.numpy(), y_pred.data.numpy(), 'r-', lw=5)
42
plt.text(2, 20, 'Loss=%.4f' % loss.data.numpy(), fontdict={'size': 20, 'color': 'red'})
43
plt.xlim(1.5, 10)
44
plt.ylim(8, 28)
45
plt.title("Iteration: {}\nw: {} b: {}".format(iteration, w.data.numpy(), b.data.numpy()))
46
plt.pause(0.5)
47
48
# 如果 MSE 小于 1,则停止训练
49
if loss.data.numpy() < 1:
50
break
Copied!
训练的直线的可视化如下:
在 80 次的时候,Loss 已经小于 1 了,因此停止了训练。
参考资料
如果你觉得这篇文章对你有帮助,不妨点个赞,让我有更多动力写出好文章。
我的文章会首发在公众号上,欢迎扫码关注我的公众号张贤同学
最近更新 1yr ago