pytorch——张量操作与线性回归

1、张量的操作：拼接、切分、索引和变换

一、张量拼接与切分

1.1 torch.cat() （cat()不会拓展张量的维度）

功能：将张量按维度dim进行拼接

tensors：张量序列
din：要拼接的维度

torch.cat(tensors,dim=0,out=None)

代码实际操作如下：

import numpy as np
import torchflag = True
if flag:t = torch.ones((2, 3))t_0 = torch.cat([t, t], dim=0)  #在第一维度上进行拼接，拼接后的维度是（4,3）t_1 = torch.cat([t, t], dim=1)  #在第二维度上进行拼接，拼接后的维度是（2,6）t_2 = torch.cat([t, t, t], dim=1)  #在第二维度上进行拼接，拼接后的维度是（2,9）print("t_0:{} shape:{}\nt_1:{} shape:{}\nt_2:{} shape:{}".format(t_0, t_0.shape, t_1, t_1.shape, t_2, t_2.shape))

1.2 torch.stack() (stack() 会拓展张量的维度)

功能：在新创建的维度dim上进行拼接。
举个例子，如果要求将[2,3]矩阵的内容在dim=1上进行拼接，则需要将[2,3]矩阵的内容转换为[2,1,3]的形式之后再使用和torch.cat()一样的拼接方式进行拼接，看到的一些比较好的对于torch.stack()的拼接的解释的文章可以参考一下这一篇（点击）。

tensors：张量序列
dim：要拼接的维度

torch.stack(tensors,dim=0,out=None)

具体的代码实现如下：

import numpy as np
import torchflag = True
# flag = Falseif flag:t = torch.ones((2, 3))s = torch.zeros((2, 3))t_stack = torch.stack([t, s], dim=0)   #对两个矩阵的第0维进行拓展print("\nt_stack:{} shape:{}".format(t_stack, t_stack.shape))   #拓展后的矩阵为（2，2，3）tensor([[[1., 1., 1.],[1., 1., 1.]],[[0., 0., 0.],[0., 0., 0.]]]) t_stack = torch.stack([t, s], dim=1)   #对两个矩阵的第1维进行拓展print("\nt_stack:{} shape:{}".format(t_stack, t_stack.shape))   #拓展后的矩阵为（2，2，3）tensor([[[1., 1., 1.],[0., 0., 0.]],[[1., 1., 1.],[0., 0., 0.]]])t_stack = torch.stack([t, s], dim=2)   #对两个矩阵的第2维进行拓展print("\nt_stack:{} shape:{}".format(t_stack, t_stack.shape))   #拓展后的矩阵为（2，3，2）tensor([[[1., 0.],[1., 0.],[1., 0.]],[[1., 0.],[1., 0.],[1., 0.]]])

1.3 torch.chunk()

功能：将张量按维度dim进行平均切分
返回值：张量列表
注意事项：若不能整除，最后一份张量小于其他张量

input：要切分的张量
chunks：要切分的份数
dim：要切分的维度

torch.chunk(input,chunks,dim=0)

具体的代码示例如下：

import numpy as np
import torchflag = True
# flag = Falseif flag:a = torch.ones((2, 5))  #创建一个矩阵list_of_tensors = torch.chunk(a, dim=1, chunks=2)  #从第一维度将矩阵划分为两部分，因为5不能被2整除，所以得到的两个矩阵中，一个矩阵为（2，3），一个矩阵为（2，2）for idx, t in enumerate(list_of_tensors):print("第{}个张量：{}， shape is {}".format(idx+1, t, t.shape))

1.4 torch.split()

功能：将张量按维度dim进行切分
返回值：张量列表

tensors：要切分的张量
split_size_or_sections：为int时，表示每一份的长度；为list时，按list元素切分
dim：要切分的维度

torch.split(tensor,split_size_or_sections,dim=0)

具体的代码示例如下：

import numpy as np
import torch
flag = True
# flag = Falseif flag:t = torch.ones((2, 5))list_of_tensors = torch.split(t, 2, dim=1)  #2表示每一份的长度，最后得到划分后的三份矩阵，分别为（2，2），（2，2），（2，1）for idx, t in enumerate(list_of_tensors):print("第{}个张量：{}， shape is {}".format(idx+1, t, t.shape))

import numpy as np
import torch
flag = True
# flag = Falseif flag:t = torch.ones((2, 5))list_of_tensors = torch.split(t, [2, 1, 2], dim=1)  #根据列表进行划分，划分后的三个矩阵的形状分别为（2，2），（2，1），（2，2）for idx, t in enumerate(list_of_tensors):print("第{}个张量：{}， shape is {}".format(idx + 1, t, t.shape))

二、张量索引

2.1 torch.index_select()

功能：在维度dim上，按index索引数据
返回值：依index索引数据拼接的张量

input：要索引的张量
dim：要索引的维度
index：要索引数据的序号

torch.index_select(input,dim,index,out=None)

具体的代码示例如下：

import numpy as np
import torch
flag = True
# flag = Falseif flag:t = torch.randint(0, 9, size=(3, 3))  #随机生成（3，3）的二维矩阵idx = torch.tensor([0, 2], dtype=torch.long)   #要索引的序列，注意dtype必须是torch.long不能是torch.floatt_select = torch.index_select(t, dim=0, index=idx)  #以第0维为索引的维度，最后得到的矩阵为（2，3）print("t:\n{}\nt_select:\n{}".format(t, t_select))

2.2 torch.masked_select()

功能：按mask中的True进行索引
返回值：一维张量

input：要索引的张量
mask：与input同形状的布尔类型张量

torch.masked_select(input,mask,out=None)

具体的代码示例如下：

import numpy as np
import torch
flag = True
# flag = Falseif flag:t = torch.randint(0, 9, size=(3, 3))mask = t.ge(5) #ge的意思是大于等于，greater than or equal，同样的有gt：greater than 和le、lt，ge的作用是找t中大于等于5的数赋值为True，小于5的数赋值为Falset_select = torch.masked_select(t, mask)  #按mask中的True进行索引返回一个一维矩阵print("t:\n{}\nmask:\n{}\nt_select:\n{}".format(t, mask, t_select))

三、张量变换

3.1 torch.reshape()

功能：变换张量形状
注意事项：当张量在内存中是连续时，新张量与input共享数据内存

input：要变换的张量
shape：新张量的形状

torch.reshape(input,shape)

具体的代码示例如下：

import numpy as np
import torch
flag = True
# flag = Falseif flag:t = torch.randperm(8)   #0-8之间随机排列的8个数t_reshape = torch.reshape(t, (-1, 2, 2))    #一维矩阵被重新reshape为（2，2，2）形式print("t:{}\nt_reshape:\n{}".format(t, t_reshape))t[0] = 1024   #将t[0]的值进行修改print("t:{}\nt_reshape:\n{}".format(t, t_reshape))  print("t.data 内存地址：{}".format(id(t.data)))  #t.data的内存地址和t_reshape的内存地址是一样的print("t_reshape.data 内存地址：{}".format(id(t_reshape.data )))

3.2 torch.transpose()

功能：交换张量的两个维度

input：要交换的张量
dim0：要交换的维度
dim1：要交换的维度

torch.transpose(input,dim0,dim1)

具体的代码示例如下：

import numpy as np
import torch
flag = True
# flag = Falseif flag:t = torch.rand((2, 3, 4))t_transpose = torch.transpose(t, dim0=0, dim1=1)   #经过交换后张量的维度变为（3，2，4）print("t shape:{}\nt_transpose shape:{}".format(t.shape, t_transpose.shape))

3.3 torch.t()

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

torch.t(input)

3.4 torch.squeeze()

功能：压缩长度为1的维度（轴）

dim：若为None，移除所有长度为1的轴；若指定维度，当且仅当该轴长度为1时，可以被移除

torch.squeeze(input,dim=None,out=None)

具体示例代码如下：

import numpy as np
import torch
flag = True
# flag = Falseif flag:t = torch.rand((1, 2, 3, 1))t_sq = torch.squeeze(t)  #将所有轴长为1的都去掉，t_sq变为（2，3）t_0 = torch.squeeze(t, dim=0)   #第0维如果是1，则将第0维去掉，t_0变为（2，3，1）t_1 = torch.squeeze(t, dim=1)   #第1维是2，不是1，所以不能删除，t_1仍然为（1，2，3，1）print(t.shape)print(t_sq.shape)print(t_0.shape)print(t_1.shape)

3.5 torch.unsqueeze()

功能：依据dim扩展维度

dim：扩展的维度

torch.usqueeze(input,dim,out=None)

2、张量的数学运算

一、加减乘除

torch.add()

功能：逐元素计算 input + alpha x other （这里面add不仅仅有加法的功能还有乘法的功能，因为在深度学习中经常需要用到这样的情况）。类似的用法还有：
torch.addcdiv() : out = input + value x tensor1 / tensor2
torch.addcmul() : out = input + value x tensor1 x tensor2

input：第一个张量
alpha：乘项因子
other：第二个张量

torch.add(input,alpha=1,other,out=None)

具体的代码示例如下：

import numpy as np
import torch
flag = True
# flag = Falseif flag:t_0 = torch.randn((3, 3))  #创建一个（3，3）正态分布的矩阵t_1 = torch.ones_like(t_0)  #创建一个（3，3）的全1矩阵t_add = torch.add(t_0, 10, t_1)  print("t_0:\n{}\nt_1:\n{}\nt_add_10:\n{}".format(t_0, t_1, t_add))

torch.addcdiv()
torch.addcmul()

torch.addcuml(input,value=1,tensor1,tensor2,out=None)

torch.sub()
torch.div()
torch.mul()

二、对数，指数，幂函数

torch.log(input,out=None)
torch.log10(input,out=None)
torch.log2(input,out=None)
torch.exp(input,out=None)
torch.pow()

三、三角函数

torch.abs(input,out=None)
torch.acos(input,out=None)
torch.cosh(input,out=None)
torch.cos(input,out=None)
torch.asin(input,out=None)
torch.atan(input,out=None)
torch.atan2(input,other,out=None)

3、线性回归

线性回归是分析一个变量与另外一（多）个变量之间关系的方法

因变量：Y 自变量：x 关系：线性 y = wx + b 分析：求解w，b

求解步骤

1、确定模型 model: y = wx + b
2、选择损失函数 MSE，均方误差
3、求解梯度并更新w,b

使用pytorch的一个具体线性回归公式推导代码：

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)  rand是生成均匀分布的20个点，再乘于10，范围就是0-10之间
y = 1*x + (5 + torch.randn(20, 1))  # y data (tensor), shape=(20, 1)，torch.randn(20, 1)是噪声，符合正态分布# 构建线性回归参数
w = torch.randn((1), requires_grad=True)  #线性函数中只有一个w，先随机初始化一个w
b = torch.zeros((1), requires_grad=True)  #线性回归中只有一个b，先随机初始化b的值为0for iteration in range(1000):# 前向传播wx = torch.mul(w, x)  #将w和x的值相乘y_pred = torch.add(wx, b)   #计算wx + b的值# 计算 MSE lossloss = (0.5 * (y - y_pred) ** 2).mean()   #计算损失函数# 反向传播loss.backward()    #使用自带的梯度求导模块# 更新参数b.data.sub_(lr * b.grad)w.data.sub_(lr * w.grad)b.grad.zero_()    #将张量梯度清零w.grad.zero_()    #将张量梯度清零# 绘图if iteration % 20 == 0:   #每迭代20次进行一次输出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:   #如果损失函数的值小于0.8则停止循环break

最后得到的线性回归拟合公式如下图所示：

————————————————
本篇幅的所有内容是基于深度之眼的pytorch课程的视频进行摘录的，所有代码均来自视频中余老师的讲解，如有侵权，请联系我进行删除。

pytorch——张量操作与线性回归相关推荐

Pytorch张量操作详解
文章目录一.前置条件二.操作 1.指定长度的顺序向量[arange] 2.查看元素总数[numel] 3.改变张量形状[reshape] 4.查看张量形状[shape] 5.全0张量[zeros] ...
pytorch线性回归代码_[PyTorch 学习笔记] 1.3 张量操作与线性回归
本章代码:https://github.com/zhangxiann/PyTorch_Practice/blob/master/lesson1/linear_regression.py 张量的操作拼 ...
pytorch张量操作基础
张量是pytorch的基本数据类型,因此有必要重新快速的学习下怎么使用操作张量. 1:使用tensor直接创建 b = torch.tensor([[11, 22, 33, 66], [77, 44, ...
深度学习与Pytorch入门实战（一）Pytorch张量操作
1. 数据类型如何表示string? One-hot [0, 1, 0, 0, ...] Embedding Word2vec glove 类型推断 import torch# type check ...
PyTorch框架学习（二） — 一文精通张量操作
PyTorch框架学习(二) - 张量操作与线性回归 1 张量的操作 1.1 拼接 1.2 切分 1.3 索引 1.4 变换 2 张量的数学运算 2.1 加法运算 2.2 减法运算 2.3 哈达玛积运 ...
pytorch张量_PyTorch张量-详细概述
pytorch张量 In this PyTorch tutorial, we'll discuss PyTorch Tensor, which are the building blocks of t ...
PyTorch系列入门到精通——张量操作线性回归
PyTorch系列入门到精通--张量操作线性回归
python中tolist_高效的张量操作 Pytorch中就占5种
PyTorch是一个基于Python的科学包,用于使用一种称为张量的特殊数据类型执行高级操作. 虽然也有其他方式可以实现相同的效果,但今天分享的这5个操作更加方便高效,值得一试. 什么是张量? 张量是 ...
PyTorch框架学习三——张量操作
PyTorch框架学习三--张量操作一.拼接 1.torch.cat() 2.torch.stack() 二.切分 1.torch.chunk() 2.torch.split() 三.索引 1.to ...

pytorch——张量操作与线性回归

pytorch——张量操作与线性回归相关推荐

最新文章

热门文章