PyTorch_Note03_张量的基本操作与线性回归

本篇为在 深度之眼 学习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➗tensor2

• torch.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，即步长，学习率

实验代码:

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