当前位置: 首页 > news >正文

Pytorch基本语法

Pytorch

    • Pytorch的基本使用
      • 基本使用
        • 张量的简介
        • 1.张量的基本类型
        • 2.张量的创建
          • 1).基本创建方式
          • 1.torch.tensor()根据指定数据创建张量
          • 2.torch.Tensor() 根据指定形状创建张量,也可以用来创建指定数据的张量
          • 3.torch.IntTensor()、torch.FloatTensor()、torch.DoubleTensor() 创建指定类型的张量
          • 2) 创建线性张量和随机张量
          • 1.torch.arange(),torch.linspace()创建线性张量
          • 2.随机种子操作
          • 查看随机种子:torch.inital_seed()
          • 设置随机种子:torch.manual_seed()
          • 创建随机张量:torch.randn()
          • 3).创建0-1张量
          • 1.创建全0张量:torch.zeros 和 torch.zeros_like
          • 2.创建全1张量:torch.ones 和torch.ones_like
          • 3.创建指定值张量:torch.full 和 torch.full_like
          • 4).元素类型转换
          • 1.data.type(torch.DoubleTensor):小数形式
          • 2.data.double()
          • 5).总结
          • <1> 创建张量的方式
          • <2> 创建线性数据和随机张量
          • <3> 创建0-1张量
          • <4> 元素类型转换:两种方式
        • 3.类型的转换
          • 1).张量转换为numpy数组
          • 使用Tensor.numpy函数将张量转换为ndarray数组,但是共享内存,可以使用copy函数避免共享
          • 2).将numpy数组转换为张量
          • 使用from_numpy可以将ndarray数组转换为Tensor.默认共享内存,使用copy可避免
          • 使用torch.tensor可以将ndarray数组转化为Tensor,默认不共享内存
          • 3).标量张量和数字转换
          • 对于只有一个元素的张量,使用item()函数从张量里面提取出来
        • 4.张量的计算
          • 1).张量的基本运算
          • 加减乘除取负号:
          • 2).张量点乘运算
          • 点乘指的是两个同维矩阵对应位置的元素相乘,使用mul和运算符号实现.
          • 3)张量矩阵乘法运算
          • 行乘以列
          • 矩阵乘法运算要求第一个矩阵shape:(n,m),第二个矩阵shape:(m,p).两个矩阵点积运算为:(n,p)
          • 运算符用@来表示两矩阵的乘积
          • torch.matmul对进行运算的两个矩阵没有限定对输入的shape不用的张量,对应的最后的几个维度必须符合矩阵运算规则
        • 5.张量的运算函数
          • 均值:mean()
          • 平方根:sqrt()
          • 求和:sum()
          • 指数计算:exp()
          • 对数计算:log() 以e为底,log2() 以2为底
        • 6.张量索引操作
          • 操作张量时,要获取某些元素处理和修改 ,需要了解torch中索引操作
          • 准备数据
          • 1)简单行列索引的使用
          • 2)列表索引范围的使用
          • 3)范围索引的使用
          • 4)布尔值索引的使用
          • 5)多维索引的使用
        • 7.张量的形状操作
          • 深度学习模型都是以某种方式操作张量,由于矩阵乘法的规则,如果形状不同会遇到错误,可使用修改形状
          • 举例说明
          • 1).reshape 函数可以保证张量数据不变的前提下改变数据的维度,并将其转换为指定的形状.
          • 使用torch.reshape()增加一个维度
          • 使用torch.reshape()改变形状
          • 2). view/contiguous
          • view函数也可用于修改张量的结构,只能用于存储在整块内存中的张量
          • 先查看张量是否在一整块内存中:使用is_contiguous
          • 使用contiguous函数转换为整块内存中的张量,在使用函数view函数
          • 3)stack函数堆叠
          • 4).squeeze函数删除形状为1的维度(降维),unsqueeze函数添加形状为1的维度(升维)
          • 5).transpose函数可以实现交换张量形状的指定维度,例如一个张量的形状为(2,3,4),可以通过transpose把3和4交换,形状变为(2,4,3). permute函数可以一次交换更多的维度
          • 6)总结
          • <1> reshape函数可以在保证数据不变的前提下改变数据的维度
          • <2> squeeze和unsqueeze函数可以用来增加或减少维度
          • <3> transpose函数可以实现交换张量形状的指定维度,permute可以一次交换更多的维度
          • <4> view函数可用于修改张量的形状,但内存必须得连续的一般结合contiguous函数使用

Pytorch的基本使用

基本使用

张量的简介
  • 例如:例如,图像可以表示为形状为 [3, 224, 224] 的张量,这意味着 [colour_channels, height, width] ,因为图像具有 3 颜色通道(红色、绿色、蓝色),高度为 224 像素,宽度为 224 像素。
  • 在张量的语言中,张量将具有三个维度,一个维度表示colour_channels,height和width.
1.张量的基本类型
import torch# 0维张量:标量(scalar)
scalar = torch.tensor(8)
print(scalar.ndim)# 1维张量:向量(vector)
vector = torch.tensor([8, 8])
print(vector.ndim)# 2维张量:矩阵(matrix)
matrix = torch.tensor([[8, 8], [9, 8]])
print(matrix.ndim)# 多维张量
tensor = torch.tensor([[[1, 1], [2, 2], [3, 3], [4, 4]]])
print(tensor.ndim)
2.张量的创建
1).基本创建方式
torch.tensor 根据指定数据类型创建张量
torch.Tensor 跟据形状创建张量,,也可用来创建指定数据的张量
torch.IntTensor,FloatTensor,DoubleTensor创建指定类型张量
  • 1.torch.tensor()根据指定数据创建张量
    # 1.创建张量标量
    data = torch.tensor(10)
    print(data)# 2.numpy数组,由于data为float64,下面代码也用该类型
    data = np.random.randn(2, 3)
    data = torch.tensor(data)
    print(data)# 3.列表,下面代码使用默认元素类型为float32
    data = torch.tensor([[10., 20., 30.], [1., 2., 3.]])
    print(data)
    
  • 2.torch.Tensor() 根据指定形状创建张量,也可以用来创建指定数据的张量
    # 1.创建2行3列的张量,默认dtype类型为float32
    data = torch.Tensor(2, 3)
    print(data)# 2,如果传递列表则创建包括指定元素的张量
    data = torch.Tensor([10])
    print(data)
    
  • 3.torch.IntTensor()、torch.FloatTensor()、torch.DoubleTensor() 创建指定类型的张量
    # 1. 创建2行3列, dtype 为 int32 的张量
    data = torch.IntTensor(2, 3)
    print(data)
    >>> tensor([[ 0, 1610612736, 1213662609],[ 805308409,  156041223,  1]], dtype=torch.int32)# 2. 注意: 如果传递的元素类型不正确, 则会进行类型转换
    data = torch.IntTensor([2.5, 3.3])
    print(data)
    >>> tensor([2, 3], dtype=torch.int32)# 3. 其他的类型
    data = torch.ShortTensor()  # int16
    data = torch.LongTensor()   # int64
    data = torch.FloatTensor()  # float32
    data = torch.DoubleTensor() # float64
    
2) 创建线性张量和随机张量
  • 1.torch.arange(),torch.linspace()创建线性张量
# 1.在指定区间按照步长生成元素arange:左闭右开[start,end,step)
data = torch.arange(0, 10, 2)
print(data)# 2.在指定区间按照元素个数生成linspace:[start,end,steps) :包左包右
data = torch.linspace(0, 11, 10)
print(data)
3).创建0-1张量
  • 1.创建全0张量:torch.zeros 和 torch.zeros_like
    # 1.创建全0张量
    data5 = torch.zeros(2, 3)
    print(data5)
    # 2.根据形状创建全0的张量
    data6 = torch.zeros_like(data5)
    print(data6)
    
  • 2.创建全1张量:torch.ones 和torch.ones_like
    # 1.创建全1张量
    data7 = torch.ones(3, 5)
    print(data7)
    # 2.根据形状创建全1张量
    data8 = torch.ones_like(data7)
    print(data8)
    
  • 3.创建指定值张量:torch.full 和 torch.full_like
    # 1.创建指定类型张量
    data9 = torch.full([2, 3], 8)
    print(data9)
    # 2.根据张量形状创建指定值的张量
    data10 = torch.full_like(data9,1)
    print(data10)
    
4).元素类型转换
  • 1.data.type(torch.DoubleTensor):小数形式
    data = torch.full([2, 3], 10)
    print(data.dtype)
    # 将data元素类型转换为float64
    data = data.type(torch.DoubleTensor)
    print(data.dtype)
    # 转换为其他类型
    # # int16
    # data = data.type(torch.ShortTensor)
    # # int32
    # data = data.type(torch.IntTensor)
    # # int64
    # data = data.type(torch.LongTensor)
    # # float32
    # data = data.type(torch.FloatTensor)
    # # float64
    # data = data.type(torch.DoubleTensor)
    
  • 2.data.double()
    # 转换为float64类型
    data = data.double()
    print(data.dtype)
    # 转换为其他类型
    # data = data.short()
    # data = data.int()
    # data = data.long()
    # data = data.float()
    # data = data.double()
    
5).总结
  • <1> 创建张量的方式
torch.tensor根据数据创建torch.Tensor根据形状创建,也可用来创建指定数据的张量torch.IntTensor(),torch.FloatTensor(),torch.DoubleTensor()创建指定类型的张量
  • <2> 创建线性数据和随机张量
torch.arange指定步长和torch.linspsce()指定数量:线性张量
查看随机种子:torch.random.initial_seed()
设置随机种子:torch.random.manual_seed()
torch.randn()创建随机张量
  • <3> 创建0-1张量
torch.zreos() 和 troch.zeros_like() 创建全0的张量
torch.ones() 和 torch.ones_like() 创建全1的张量
torch.full 和 torch.full_like() 创建全为指定值的张量
  • <4> 元素类型转换:两种方式
data.type(torch.DoubleTensor)
data.double()
3.类型的转换
1).张量转换为numpy数组
  • 使用Tensor.numpy函数将张量转换为ndarray数组,但是共享内存,可以使用copy函数避免共享
# 1.将张量转为numpy数组
data_tensor = torch.tensor([2, 3, 4])
# 使用张量对象中的numpy函数转换
data_numpy = data_tensor.numpy()
print(type(data_tensor))
print(type(data_numpy))
# 注意data_tensor和data_numpy共享内存
data_numpy[1] = 100
print(data_tensor)
print(data_numpy)# 2.对象拷贝避免 共享内存
data_tensor = torch.tensor([2, 3, 4])
data_numpy = data_tensor.numpy().copy()
# 添加copy不会共享内存,修改任意一个不会发生变化
data_numpy[1] = 100
print(data_tensor)
print(data_numpy)
2).将numpy数组转换为张量
  • 使用from_numpy可以将ndarray数组转换为Tensor.默认共享内存,使用copy可避免
data_numpy = np.array([2, 3, 4])
# 将numpy数组转化为张量
# 使用from_numpy,默认共享内存,可添加copy()
data_tensor = torch.from_numpy(data_numpy.copy())
# 共享内存
data_tensor[1] = 100
print(data_numpy)
print(data_tensor)
  • 使用torch.tensor可以将ndarray数组转化为Tensor,默认不共享内存
data_numpy = np.array([2, 3, 4])
data_tensor = torch.tensor(data_numpy)
# 使用torch.tensor默认不共享内存
data_tensor[1] = 100
print(data_numpy)
print(data_tensor)
3).标量张量和数字转换
  • 对于只有一个元素的张量,使用item()函数从张量里面提取出来
# 当张量只包含一个元素时,可以通过item函数提取出该值
data = torch.tensor([20, ])
print(data)
print(data.item())data = torch.tensor(30)
print(data.item())
4.张量的计算
1).张量的基本运算
  • 加减乘除取负号:
add,sub,mul,div,neg
add_,sub_,mul_,div_,neg_带下划线会修改原始数据
# 设置随机种子方便观察运算
torch.random.manual_seed(21)
data = torch.randint(0, 10, [2, 3])
print(data)
# 1.不修改原数据
# 等价于 new_data = data + 10
new_data = data.add(10)
print(new_data)
# 2.直接修改原数据
data.add_(10)
print(data)
# 3.减
data_sub = data.sub(100)
print(data_sub)
# 4.乘
data_mul = data.mul(10)
print(data_mul)
# 5.除
data_div = data.div(100)
print(data_div)
# 6.取负号
data_neg = data.neg()
print(data_neg)
2).张量点乘运算
  • 点乘指的是两个同维矩阵对应位置的元素相乘,使用mul和运算符号实现.
# 创建两个同维矩阵
data1 = torch.tensor([[1, 2], [3, 4]])
data2 = torch.tensor([[5, 6], [7, 8]])
# 第一种方式: torch.mul(data1,data2)
data3 = torch.mul(data1, data2)
print(data1)
print(data2)
print(data3)
3)张量矩阵乘法运算
# 点积运算
data1 = torch.tensor([[1, 2], [3, 4], [5, 6]])
data2 = torch.tensor([[7, 8], [9, 10]])
# 方式1:顺序不能错满足矩阵乘法运算条件
data3 = data1 @ data2
print(data1)
print(data2)
print(data3)
# 方式2:torch.matmul(data1,data2)
data3 = torch.matmul(data1, data2)
print(data3)
5.张量的运算函数
torch.random.manual_seed(21)
# 创建一个三行四列用0,10填充的张量:计算类型必须为小数和复数
data = torch.randint(0, 10, [3, 4], dtype=torch.float64)
print(data)
# 1.计算均值
print(data.mean())
# 按列计算均值
print(data.mean(dim=0))
# 按行计算均值
print(data.mean(dim=1))
# 2,计算总和
print(data.sum())
# 按列计算总和
print(data.sum(dim=0))
# 按行计算总和
print(data.sum(dim=1))
# 3.计算平方
print(torch.pow(data, 2))
# 4.计算平方根
print(data.sqrt())
# 5.指数计算
print(data.exp())
# 6.对数计算
print(data.log())
print(data.log2())
print(data.log10())
6.张量索引操作
  • 操作张量时,要获取某些元素处理和修改 ,需要了解torch中索引操作
准备数据
import torch# 设置随机种子
torch.random.manual_seed(21)
data = torch.randint(0, 10, [5, 5])
print(data)
1)简单行列索引的使用
# 1.简单行列索引的使用
# 第0行
print(data[0])
# 所有行第0列的数据
print(data[:, 0])
2)列表索引范围的使用
# 2.列表索引的使用
# 返回(0,2),(1,3)两个位置元素
print(data[[1, 3], [1, 3]])
# 返回 0、1 行的 1、2 列共4个元素
print(data[[[0], [1]], [1, 2]])
3)范围索引的使用
# 3.范围索引的使用
# 前3行的前2列数据
print(data[:3, :2])
# 第2行到最后的前2列数据
print(data[2:, :2])
# 第0行、第2行的第0、1两列数据
print(data[0:3:2, :2])
4)布尔值索引的使用
# 4.布尔值索引的使用
# 第三列大于5的行数据
print(data[data[:, 2] > 5])
# 第二行大于5的列数据
print(data[:, data[1] > 5])
5)多维索引的使用
#  5.多维索引的使用
# 设置随机种子
torch.random.manual_seed(21)
# 创建3个通道,4行5列的张量
data = torch.randint(0, 10, [3, 4, 5])
print(data)
# 获取0轴上的第一个数据
print(data[0, 0, :])
# 获取1轴上的第一个数据
print(data[1, 0, :])
# 获取2轴上的第一个数据
print(data[2, 0, :])
# 3维索引,第1通道,第1,2行,第2,3列
print(data[1, 1:3, 2:4])
# 3维索引,第2通道,第0,3行,第0,3列
print(data[2, 0:4:3, 0:4:3])
7.张量的形状操作
  • 深度学习模型都是以某种方式操作张量,由于矩阵乘法的规则,如果形状不同会遇到错误,可使用修改形状
举例说明
import torchx = torch.arange(1., 8.)
print(x)
# 查看张量形状
print(x.shape)
print(x.size())
1).reshape 函数可以保证张量数据不变的前提下改变数据的维度,并将其转换为指定的形状.
  • 使用torch.reshape()增加一个维度
import torchx = torch.arange(1., 8.)
print(x)
# 查看张量形状
print(x.shape)
print(x.size())# 1.torch.reshape可升维降维
# 增加一个维度
x_reshape = x.reshape(1, 7)
print(x_reshape)
print(x_reshape.shape)
  • 使用torch.reshape()改变形状
# 1.使用torch.reshape()来改变张量的形状
data = torch.tensor([[1, 2, 3], [4, 5, 6]])
# 使用shape和size获取张量的形状
print(data.shape, data.shape[0], data.shape[1])
print(data.size(), data.size(0), data.size(1))
# 2.使用reshape函数修改张量的形状# reshape(1, -1):
# 第一个参数 1 表示新数组的第一维大小为 1。
# 第二个参数 -1 表示让 NumPy 自动计算这一维的大小,以保持数据的总长度不变。new_data = data.reshape(1, -1)
print(new_data)
2). view/contiguous
# 1.一个张量经过transpose或者permute函数处理后,无法使用view函数进行改变形状的操作
# 可使用contiguous函数变成连续在使用view函数
# 2.加载数据判断张量是否使用整块内存
data = torch.tensor([[1, 2, 3], [4, 5, 6]])
print(data, data.shape)
#  1.判断是否使用整块内存
print(data.is_contiguous())
# 2.view函数
# -1表示自动计算维度大小,保持总数据不变
data1 = data.view(3, -1)
print(data1)
# 3.判断是否使用整块内存
print(data1.is_contiguous())
# 4.使用函数transpose函数修改形状
# 交换维度 把行列交换
data3 = torch.transpose(data, 0, 1)
print(data3, data3.shape)
# 判断是否使用整块内存
print(data3.is_contiguous())
# 5.使用函数contiguous转换
data4 = data3.contiguous().view(2, -1)
print(data4)
3)stack函数堆叠
#  1.stack函数堆叠
# 根据需求按行或按列
data1 = torch.stack([data, data, data], dim=0)
print(data)
print(data1)
4).squeeze函数删除形状为1的维度(降维),unsqueeze函数添加形状为1的维度(升维)
# 1.unsqueeze升维data1 = torch.tensor([[1, 2, 3, 4, 5]])
print(data1.shape)# unsqueeze升维,在0位置指定位置插入新的维度变为1行5列:dim=0
data2 = data1.unsqueeze(dim=0)
print(data2)# 维度变成5行1列:dim=1
data3 = data1.unsqueeze(dim=1)
print(data3)#  dim=-1在最后的位置插入一个维度
data4 = data1.unsqueeze(dim=-1)
print(data4)
data5 = data1.unsqueeze(dim=2)
print(data5)# 2.squeeze降维:直接降维1维# 也可添加参数dim指定用来指定要降低的维度
data6 = data1.squeeze()
print(data6)
data7 = data1.squeeze(dim=0)
print(data7)
5).transpose函数可以实现交换张量形状的指定维度,例如一个张量的形状为(2,3,4),可以通过transpose把3和4交换,形状变为(2,4,3). permute函数可以一次交换更多的维度
# 1.transpose函数交换维度
# 随机种子
torch.random.manual_seed(21)
data1 = torch.tensor(np.random.randint(0, 10, [3, 4, 5]))
data2 = torch.randint(0, 10, [3, 4, 5])
print(data1.shape)
print(data2.shape)
# 1.交换1,2维度
data3 = torch.transpose(data1, 1, 2)
print(data3.shape)
# 2 将data 的形状修改为 (4, 5, 3), 需要变换多次
data4 = torch.transpose(data1, 0, 1)
print(data4.shape)
data5 = torch.transpose(data4, 1, 2)
print(data5.shape)# 3.使用permute函数修改形状为(4, 5, 3)
# 方法1:torch.permute
data6 = torch.permute(data1, [1, 2, 0])
print(data6.shape)
# 方法2:data1.permute
data7 = data1.permute([1, 2, 0])
print(data7.shape)
print(data7)
6)总结

http://www.mrgr.cn/news/68507.html

相关文章:

  • 经典的ORACLE 11/12/19闪回操作
  • 深入理解 Git 及其工具的用途、使用方法与区别
  • 在OceanBase 中,实现自增列的4种方法
  • ceph灾备之cephfs snapshot mirror和rsync对比
  • 基于java+SpringBoot+Vue的宠物咖啡馆平台设计与实现
  • 基于Python的旅游景点推荐系统
  • 五款小众办公助手
  • 设计模式-六个基本原则之一-单一职责原则 + 案例
  • Linux:git的了解和基础使用(保姆级教程)
  • 如何下载西瓜视频没有水印
  • 普华永道:巨额罚单来了,人早跑了
  • INDEMIND:拿捏松弛感,先从“躺平”开始
  • 智谱AI视频生成模型CogVideoX v1.5开源 支持5/10秒视频生成
  • Spark的DSL常用操作
  • 前端递归获取树(不限制层级)结构下的某个字段并组成数组返回
  • ReadKidz | 一个生成儿童故事绘本的平台
  • PG逻辑复制的REPLICA IDENTITY几种设置
  • 全自动卤煮牛肉猪头肉夹层锅:
  • vue大疆建图航拍功能实现
  • 短期电力负荷
  • C++初阶学习第十弹——深入讲解vector的迭代器失效
  • 深度图和深度值
  • 无处不在的算法,竟然帮你找到理想对象!
  • Docker Compose部署Rabbitmq(Dockerfile安装延迟队列)
  • ffmpeg视频滤镜:组合两个视频为立体视频- framepack
  • cooladmin使用整理