Pytorch的基本语法
张量简介
张量 Tensor 是机器学习的基本构建模块,是以数字方式表示数据的形式.
在张量语言(用于描述张量的语言)中,张量将具有三个维度,一个维度表示 colour_channels
、 height
和 width
。
张量的基本使用
基本类型
# 0维张量:标量(scalar)
scalar = torch.tensor(7)
scalar.ndim
>>> 0
# 1维张量:向量(vector)
vector = torch.tensor([7, 7])
vector.ndim
>>> 1
# 2维张量:矩阵(matrix)
MATRIX = torch.tensor([[7, 8],
[9, 10]])
MATRIX.ndim
>>> 2
# 多维张量
TENSOR = torch.tensor([[[1, 2, 3],
[3, 6, 9],
[2, 4, 5]]])
TENSOR.ndim
>>> 3
张量的创建
张量的基本创建方式
torch.tensor()根据指定数据创建张量
import torch
import numpy as np
# 创建张量标量
data = torch.tensor(10)
print(data)
# 2. numpy 数组, 由于 data 为 float64, 下面代码也使用该类型
data = np.random.randn(2, 3)
data = torch.tensor(data)
print(data)
>>> tensor([[ 0.1345, 0.1149, 0.2435],
[ 0.8026, -0.6744, -1.0918]], dtype=torch.float64)
# 3. 列表, 下面代码使用默认元素类型 float32
data = [[10., 20., 30.], [40., 50., 60.]]
data = torch.tensor(data)
print(data)
>>> tensor([[10., 20., 30.],
[40., 50., 60.]])
torch.Tensor()根据指定形状创建张量,也可以用来创建指定数据的张量
# 1. 创建2行3列的张量, 默认 dtype 为 float32
data = torch.Tensor(2, 3)
print(data)
>>> tensor([[0.0000e+00, 3.6893e+19, 2.2018e+05],
[4.6577e-10, 2.4158e-12, 1.1625e+33]])
# 2. 注意: 如果传递列表, 则创建包含指定元素的张量
data = torch.Tensor([10])
print(data)
>>> tensor([10.])
data = torch.Tensor([10, 20])
print(data)
>>> tensor([10., 20.])
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
创建线性张量和随机张量
torch.arange() torch.linspace()创建线性张量
# 1. 在指定区间按照步长生成元素 [start, end, step) 左闭右开
data = torch.arange(0, 10, 2)
print(data)
>>> tensor([0, 2, 4, 6, 8])
# 2. 在指定区间按照元素个数生成 [start, end, steps] 左闭右闭
data = torch.linspace(0, 11, 10)
print(data)
>>> tensor([0.0000, 1.2222, 2.4444, 3.6667, 4.8889, 6.1111, 7.3333, 8.5556, 9.7778,
随机种子操作
- torch.random.initial_seed()查看随机种子
- torch.random.manual_seed() 设置随机数种子
- torch.randn() 创建随机张量
# 1. 创建随机张量
data = torch.randn(2, 3) # 创建2行3列张量
print(data)
>>> tensor([[-0.5209, -0.2439, -1.1780],
[ 0.8133, 1.1442, 0.6790]])
# 2.查看随机数种子
print('随机数种子:', torch.random.initial_seed())
>>> 随机数种子: 4508475192273306739
# 3.设置随机数种子
torch.random.manual_seed(100)
data = torch.randn(2, 3)
print(data)
print('随机数种子:', torch.random.initial_seed())
>>> tensor([[ 0.3607, -0.2859, -0.3938],
[ 0.2429, -1.3833, -2.3134]])
随机数种子: 100
创建0-1张量
- torch.ones 和 torch.ones_like 创建全1张量
- torch.zeros 和 torch.zeros_like 创建全0张量
- torch.full 和 torch.full_like 创建全为指定值张量
torch.ones()、torch.ones_like() 创建全1张量
# 1. 创建指定形状全0张量
data = torch.zeros(2, 3)
print(data)
>>> tensor([[0., 0., 0.],
[0., 0., 0.]])
# 2. 根据张量形状创建全0张量
data = torch.zeros_like(data)
print(data)
>>> tensor([[0., 0., 0.],
[0., 0., 0.]])
torch.zeros()、torch.zeros_like() 创建全0张量
# 1. 创建指定形状全1张量
data = torch.ones(2, 3)
print(data)
>>> tensor([[1., 1., 1.],
[1., 1., 1.]])
# 2. 根据张量形状创建全1张量
data = torch.ones_like(data)
print(data)
>>> tensor([[1., 1., 1.],
[1., 1., 1.]])
torch.full()、torch.full_like() 创建全为指定值张量
# 1. 创建指定形状指定值的张量
data = torch.full([2, 3], 10)
print(data)
>>> tensor([[10, 10, 10],
[10, 10, 10]])
# 2. 根据张量形状创建指定值的张量
data = torch.full_like(data, 20)
print(data)
>>> tensor([[20, 20, 20],
[20, 20, 20]])
张量元素类型转换
- data.type(torch.DoubleTensor)
- data.double()
data.type(torch.Double Tensor)
data = torch.full([2, 3], 10)
print(data.dtype)
>>> torch.int64
# 将 data 元素类型转换为 float64 类型
data = data.type(torch.DoubleTensor)
print(data.dtype)
>>> torch.float64
# 转换为其他类型
# data = data.type(torch.ShortTensor) # int16
# data = data.type(torch.IntTensor) # int32
# data = data.type(torch.LongTensor) # int64
# data = data.type(torch.FloatTensor) # float32
data.double()
data = torch.full([2, 3], 10)
print(data.dtype)
>>> torch.int64
# 将 data 元素类型转换为 float64 类型
data = data.double()
print(data.dtype)
>>> torch.float64
# 转换为其他类型
# data = data.short()
# data = data.int()
# data = data.long()
# data = data.float()
张量的类型转换
张量转换为Numpy数组
- 使用 Tensor.numpy 函数可以将张量转换为 ndarray 数组,但是共享内存,可以使用 copy 函数避免共享。
# 1. 将张量转换为 numpy 数组
data_tensor = torch.tensor([2, 3, 4])
# 使用张量对象中的 numpy 函数进行转换
data_numpy = data_tensor.numpy()
print(type(data_tensor))
>>> <class 'torch.Tensor'>
print(type(data_numpy))
>>> <class 'numpy.ndarray'>
# 注意: data_tensor 和 data_numpy 共享内存
# 修改其中的一个,另外一个也会发生改变
# data_tensor[0] = 100
data_numpy[0] = 100
print(data_tensor)
>>> tensor([100, 3, 4])
print(data_numpy)
>>> [100 3 4]
# 2. 对象拷贝避免共享内存
data_tensor = torch.tensor([2, 3, 4])
# 使用张量对象中的 numpy 函数进行转换,通过copy方法拷贝对象
data_numpy = data_tensor.numpy().copy()
print(type(data_tensor))
>>> <class 'torch.Tensor'>
print(type(data_numpy))
>>> <class 'numpy.ndarray'>
# 注意: data_tensor 和 data_numpy 此时不共享内存
# 修改其中的一个,另外一个不会发生改变
# data_tensor[0] = 100
data_numpy[0] = 100
print(data_tensor)
>>> tensor([2, 3, 4])
print(data_numpy)
>>> [100 3 4]
Numpy转换为tensor
- 使用 from_numpy 可以将 ndarray 数组转换为 Tensor,默认共享内存,使用 copy 函数避免共享。
data_numpy = np.array([2, 3, 4])
# 将 numpy 数组转换为张量类型
# 1. from_numpy
# 2. torch.tensor(ndarray)
data_tensor = torch.from_numpy(data_numpy)
# nunpy 和 tensor 共享内存
# data_numpy[0] = 100
data_tensor[0] = 100
print(data_tensor)
>>> tensor([100, 3, 4], dtype=torch.int32)
print(data_numpy)
>>> [100 3 4]
- 使用 torch.tensor 可以将 ndarray 数组转换为 Tensor,默认不共享内存。
data_numpy = np.array([2, 3, 4])
data_tensor = torch.tensor(data_numpy)
# nunpy 和 tensor 不共享内存
# data_numpy[0] = 100
data_tensor[0] = 100
print(data_tensor)
>>> tensor([100, 3, 4], dtype=torch.int32)
print(data_numpy)
>>> [2 3 4]
标量张量和数字转换
- 对于只有一个元素的张量,使用item()函数将该值从张量中提取出来
# 当张量只包含一个元素时, 可以通过 item() 函数提取出该值
data = torch.tensor([30,])
print(data.item())
>>> 30
data = torch.tensor(30)
print(data.item())
>>> 30x
张量的数值计算
张量的基本运算
- 加减乘除取负号:
- add、sub、mul、div、neg
- add_、sub_、mul_、div_、neg_(其中带下划线的版本会修改原数据)
data = torch.randint(0, 10, [2, 3])
print(data)
>>> tensor([[3, 7, 4],
[0, 0, 6]])
# 1. 不修改原数据
new_data = data.add(10) # 等价 new_data = data + 10
print(new_data)
>>> tensor([[13, 17, 14],
[10, 10, 16]])
# 2. 直接修改原数据 注意: 带下划线的函数为修改原数据本身
data.add_(10) # 等价 data += 10
print(data)
>>> tensor([[13, 17, 14],
[10, 10, 16]])
# 3. 其他函数
print(data.sub(100))
>>> tensor([[-87, -83, -86],
[-90, -90, -84]])
print(data.mul(100))
>>> tensor([[1300, 1700, 1400],
[1000, 1000, 1600]])
print(data.div(100))
>>> tensor([[0.1300, 0.1700, 0.1400],
[0.1000, 0.1000, 0.1600]])
print(data.neg())
>>> tensor([[-13, -17, -14],
[-10, -10, -16]])
张量点乘运算
- 点乘指(Hadamard)的是两个同维矩阵对应位置的元素相乘,使用mul 和运算符 * 实现。
data1 = torch.tensor([[1, 2], [3, 4]])
data2 = torch.tensor([[5, 6], [7, 8]])
# 第一种方式
data = torch.mul(data1, data2)
print(data)
>>> tensor([[ 5, 12],
[21, 32]])
# 第二种方式
data = data1 * data2
print(data)
>>> tensor([[ 5, 12],
[21, 32]])
张量矩阵乘法运算
- 矩阵乘法运算要求第一个矩阵 shape: (n, m),第二个矩阵 shape: (m, p), 两个矩阵点积运算 shape 为: (n, p)。
- 运算符 @ 用于进行两个矩阵的乘积运算
- torch.matmul 对进行乘积运算的两矩阵形状没有限定.对数输入的 shape 不同的张量, 对应的最后几个维度必须符合矩阵运算规则
# 点积运算
data1 = torch.tensor([[1, 2], [3, 4], [5, 6]])
data2 = torch.tensor([[5<