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)

2.随机种子操作
查看随机种子:torch.inital_seed()
设置随机种子:torch.manual_seed()

创建随机张量:torch.randn()

# 1.创建随机张量: 2行3列
data3 = torch.randn(2, 3)
print(data3)
# 2.查看随机数种子
print('随机数种子为:', torch.random.initial_seed())
# 3.设置随机数种子
torch.random.manual_seed(21)
data4 = torch.randn(2, 3)
print(data4)
print('随机数种子为', torch.random.initial_seed())

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)张量矩阵乘法运算

行乘以列
矩阵乘法运算要求第一个矩阵shape:(n,m),第二个矩阵shape:(m,p).两个矩阵点积运算为:(n,p)
运算符用@来表示两矩阵的乘积
torch.matmul对进行运算的两个矩阵没有限定对输入的shape不用的张量,对应的最后的几个维度必须符合矩阵运算规则

# 点积运算
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.张量的运算函数

均值:mean()
平方根:sqrt()
求和:sum()
指数计算:exp()
对数计算:log() 以e为底,log2() 以2为底

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

view函数也可用于修改张量的结构,只能用于存储在整块内存中的张量
先查看张量是否在一整块内存中:使用is_contiguous
使用contiguous函数转换为整块内存中的张量,在使用函数view函数

# 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)