Pytorch基本语法

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 torch

x = torch.arange(1., 8.)
print(x)
# 查看张量形状
print(x.shape)
print(x.size())

1).reshape 函数可以保证张量数据不变的前提下改变数据的维度,并将其转换为指定的形状.

• 使用torch.reshape()增加一个维度

import torch

x = 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)

6)总结

• <1> reshape函数可以在保证数据不变的前提下改变数据的维度

• <2> squeeze和unsqueeze函数可以用来增加或减少维度

• <3> transpose函数可以实现交换张量形状的指定维度,permute可以一次交换更多的维度

• <4> view函数可用于修改张量的形状,但内存必须得连续的一般结合contiguous函数使用