本篇为在 深度之眼 学习PyTorch笔记之一
This is one of the notes from the Deepshare
1 张量的基本操作(拼接、切分、索引以及变换)
1.1 张量的拼接
使用torch.cat()将张量按维度dim进行拼接
torch.cat(
tensors, #张量序列
dim = 0, #要拼接的维度
out = None)
实验代码一:
import torch
torch.manual_seed(1) #为CPU设置种子用于生成随机数，以使得结果是确定的
flag = True
# flag = False
if flag:
t = torch.ones((2, 3))
t_0 = torch.cat([t, t], dim=0) #在维度为0时进行拼接，结果为[4,3]
t_1 = torch.cat([t, t, t], dim=1) #在维度为1时进行拼接,结果为[2,9]
print("t_0:{} shape:{}\nt_1:{} shape:{}".format(t_0, t_0.shape, t_1, t_1.shape))
使用torch.stack()在新创建的维度dim上进行拼接
torch.stack(
tensors, #张量序列
dim = 0, #要拼接的维度
out = None)
实验代码二:
import torch
torch.manual_seed(1) #为CPU设置种子用于生成随机数，以使得结果是确定的
flag = True
# flag = False
if flag:
t = torch.ones((2, 3))
t_stack = torch.stack([t, t, t], dim=0) #创建一个维度并在0维上进行拼接，结果为[3,2,3]
print("\nt_stack:{} shape:{}".format(t_stack, t_stack.shape))
1.2 张量的切分
使用torch.chunk()将张量按维度dim进行平均切分
Ps:如果不能被整除，最后一份张量小于其他张量
torch.chunk( ##返回值为张量列表
input, #要切分的张量
chunks, #要拼接的分数
dim = 0 #要切分的维度
)
实验代码三:
import torch
torch.manual_seed(1) #为CPU设置种子用于生成随机数，以使得结果是确定的
# flag = True
flag = False
if flag:
a = torch.ones((2, 7)) # 创建（2，7）的单位阵
list_of_tensors = torch.chunk(a, dim=1, chunks=3) # 切为3份
for idx, t in enumerate(list_of_tensors):
print("第{}个张量：{}, shape is {}".format(idx+1, t, t.shape))
使用torch.split()将张量按维度dim进行切分
torch.split( #返回值为张量列表
tensor, #要切分的张量
split_size_or_sections,
#为int时，表示每一份的长度，为list时，按list元素切分
dim = 0 #要切分的维度
)
实验代码四:
import torch
torch.manual_seed(1) #为CPU设置种子用于生成随机数，以使得结果是确定的
# flag = True
flag = False
if flag:
t = torch.ones((2, 5))
list_of_tensors = torch.split(t, [2, 1, 1], dim=1) # 给定[2 , 1, 2]三个张量的长度，结果分别为[2,2],[2,1],[2,2 ]
for idx, t in enumerate(list_of_tensors):
print("第{}个张量：{}, shape is {}".format(idx+1, t, t.shape))
# list_of_tensors = torch.split(t, [2, 1, 2], dim=1)
# for idx, t in enumerate(list_of_tensors):
# print("第{}个张量：{}, shape is {}".format(idx, t, t.shape))
1.3 张量的索引
使用torch.index_select()在维度dim上，按index索引数据
torch.index_select( ##返回值依index索引数据拼接的张量
input, #要索引的张量
dim, #要索引的维度
index, #要索引数据的序号
out = None
)
实验代码五:
import torch
torch.manual_seed(1) #为CPU设置种子用于生成随机数，以使得结果是确定的
# flag = True
flag = False
if flag:
t = torch.randint(0, 9, size=(3, 3)) #创建3*3的均匀分布张量
idx = torch.tensor([0, 2], dtype=torch.long) # 必须是long长整型，不能是float
t_select = torch.index_select(t, dim=0, index=idx)
print("t:\n{}\nt_select:\n{}".format(t, t_select))
使用torch.masked_select()按mask中的True进行索引
torch.split( ##返回值为一维张量
input, #要索引的张量
mask, #与input同形状的布尔类型张量
out = None
)
实验代码六:
import torch
torch.manual_seed(1) #为CPU设置种子用于生成随机数，以使得结果是确定的
# flag = True
flag = False
if flag:
t = torch.randint(0, 9, size=(3, 3))
mask = t.le(5) # ge 大于等于 gt 大于 le 小于等于 lt 小于
t_select = torch.masked_select(t, mask)
print("t:\n{}\nmask:\n{}\nt_select:\n{} ".format(t, mask, t_select))
1.4 张量的变换
使用torch.reshape()变换张量的形状
Ps:当张量在内存中是连续的，新张量与input共享数据内存
torch.reshape(
input, #要变换的张量
shape, #要新张量的形状
)
实验代码七:
import torch
torch.manual_seed(1) #为CPU设置种子用于生成随机数，以使得结果是确定的
# flag = True
flag = False
if flag:
t = torch.randperm(8)
t_reshape = torch.reshape(t, (-1, 2, 2)) # -1表示这个维度不需要关心，8➗2➗2
print("t:{}\nt_reshape:\n{}".format(t, t_reshape))
t[0] = 1024
print("t:{}\nt_reshape:\n{}".format(t, t_reshape))
print("t.data 内存地址:{}".format(id(t.data)))
print("t_reshape.data 内存地址:{}".format(id(t_reshape.data)))
使用torch.transpose()变换张量的两个维度
torch.transpose( ##返回值为一维张量
input, #要索引的张量
dim0, #要交换的维度
dim1,
)
实验代码八:
import torch
torch.manual_seed(1) #为CPU设置种子用于生成随机数，以使得结果是确定的
# flag = True
flag = False
if flag:
# torch.transpose 图像预处理中经常用到
t = torch.rand((2, 3, 4))
t_transpose = torch.transpose(t, dim0=1, dim1=2) # 将c*h*w转换成 h*w*c
print("t shape:{}\nt_transpose shape: {}".format(t.shape, t_transpose.shape))
使用torch.t() 2维张量
torch.transpose( ##返回值为一维张量
input, #要索引的张量
dim0, #要交换的维度
dim1,
)
使用torch.squeeze()
功能: 压缩长度为1的维度(轴)
- dim: 若为None，移除所有长度为1的轴;若指定维度，当且仅当该轴长度为1时，可以被移除；
torch.squeeze(
input,
dim = None,
out = None,
)
实验代码九:
import torch
torch.manual_seed(1) #为CPU设置种子用于生成随机数，以使得结果是确定的
# flag = True
flag = False
# flag = True
flag = False
if flag:
t = torch.rand((1, 2, 3, 1))
t_sq = torch.squeeze(t)
t_0 = torch.squeeze(t, dim=0)
t_1 = torch.squeeze(t, dim=1)
print(t.shape)
print(t_sq.shape)
print(t_0.shape)
print(t_1.shape)
使用torch.unsqueeze()
功能:依据dim扩展维度
- dim：扩展的维度
torch.transpose(
input,
dim,
out = None,
)
2 张量的数学运算
2.1 加减乘除
touch.add()
touch.addcdiv()
touch.addcmul()
touch.sub()
touch.div()
touch.nul()
其中，torch.add() 有着不一样的功能
torch.add()
功能:逐元素计算 input+alpha*other #先乘后加，
- input: 第一个张量
- alpha: 乘项目因子
- other: 第二个张量
torch.add(
input,
alpha=1,
other,
out=None)
有两个在优化过程中经常使用的方法：
torch.addcdiv()实现的是加法结合除法的操作，即out=input+value*tensor1➗tensor2torch.addcmul()实现的是加法结合乘法的操作，即out=input+value*tensor1*tensor2
torch.addcmul(
input,
value=1,
tensor1,
tensor2,
out=None
)
# flag = True
flag = False
if flag:
t_0 = torch.randn((3, 3))
t_1 = torch.ones_like(t_0)
t_add = torch.add(t_0, 10, t_1)
#t_add*t_1+t_0
print("t_0:\n{}\nt_1:\n{}\nt_add_10:\n{}".format(t_0, t_1, t_add))
2.2 对数，指数，幂函数
touch.log(input,output=None)
touch.log10(input,output=None)
touch.log2(input,output=None)
touch.exp(input,output=None)
touch.pow()
2.3 三角函数
touch.abs(input,output=None)
touch.acos(input,output=None)
touch.cosh(input,output=None)
touch.cos(input,output=None)
touch.asin(input,output=None)
touch.atan(input,output=None)
touch.atan2(input,other,output=None)
3 线性回归(Liner Regression)
- 线性回归是分析一个变量与另外一（多）个变量之间关系的方法。例如：
y=wx+b中，y是因变量，x是自变量,求解w与b即求解其线性关系。 - 求解步骤为:
- 1.确定模型 (Model:
y = wx+b); - 2.选择损失函数 (MSE均方误差:
$\frac{1}{m} \sum_{i=1}^m {(y_{i}-{\hat{y_i})}}^2$); - 3.求解梯度并更新
w,b(梯度下降法:w = w - LR* w.grad, b = b -LR*w.grad); 其中， LR为Learning Rate，即步长，学习率
- 1.确定模型 (Model:
实验代码:
import torch
import matplotlib.pyplot as plt
torch.manual_seed(10)
lr = 0.05 # 学习率
# 创建训练数据
x = torch.rand(20, 1) * 10 # x data (tensor), shape=(20, 1)
y = 2*x + (5 + torch.randn(20, 1)) # y data (tensor), shape=(20, 1)
# 构建线性回归参数
w = torch.randn((1), requires_grad=True)
b = torch.zeros((1), requires_grad=True)
for iteration in range(1000):
# 前向传播
wx = torch.mul(w, x)
y_pred = torch.add(wx, b)
# 计算 MSE loss
loss = (0.5 * (y - y_pred) ** 2).mean()
# 反向传播
loss.backward()
# 更新参数
b.data.sub_(lr * b.grad)
w.data.sub_(lr * w.grad)
# 清零张量的梯度
w.grad.zero_()
b.grad.zero_()
# 绘图
if iteration % 20 == 0:
plt.scatter(x.data.numpy(), y.data.numpy())
plt.plot(x.data.numpy(), y_pred.data.numpy(), 'r-', lw=5)
plt.text(2, 20, 'Loss=%.4f' % loss.data.numpy(), fontdict={'size': 20, 'color': 'red'})
plt.xlim(1.5, 10)
plt.ylim(8, 28)
plt.title("Iteration: {}\nw: {} b: {}".format(iteration, w.data.numpy(), b.data.numpy()))
plt.pause(0.5)
if loss.data.numpy() < 1:
break
