探索PyTorch：张量的创建和数值计算-阿里云开发者社区

前言

PyTorch 是一个 Python 深度学习框架，学习PyTorch在当今深度学习领域至关重要。PyTorch以其动态计算图、易于使用的API和强大的社区支持，成为科研人员、数据科学家及工程师的首选框架。它不仅简化了模型设计、训练与部署流程，还极大地提高了实验效率和创新能力。掌握PyTorch，能够加速科研进度，促进项目落地，是在AI时代保持竞争力的关键技能之一。满满的都是干货，希望能帮助到大家！

1. 张量的创建

1.1 张量的基本概念

PyTorch 是一个 Python 深度学习框架，它将数据封装成张量（Tensor）来进行运算。
PyTorch 中的张量就是元素为同一种数据类型的多维矩阵。
PyTorch 中，张量以 "类" 的形式封装起来，对张量的一些运算、处理的方法被封装在类中。

1.2 张量的基本创建

torch.tensor 根据指定数据创建张量
torch.Tensor 根据形状创建张量, 其也可用来创建指定数据的张量
torch.IntTensor、torch.FloatTensor、torch.DoubleTensor 创建指定类型的张量

import torch
import numpy as np
# 1. 根据已有的数据创建张量
def test01():
    # 1.1 创建标量
    data = torch.tensor(10)
    print(data)
    # 1.2 使用numpy数组来创建张量
    data = np.random.randn(2, 3)
    data = torch.tensor(data)
    print(data)
    # 1.3 使用list列表创建张量
    data = [[10., 20., 30.], [40., 50., 60.]]
    data = torch.tensor(data)
    print(data)
# 2. 创建指定形状的张量
def test02():
    # 2.1 创建2行3列的张量
    data = torch.Tensor(2, 3)
    print(data)
    # 2.2 可以创建指定值的张量
    # 注意: 传递列表
    data = torch.Tensor([2, 3])
    print(data)
    data = torch.Tensor([10])
    print(data)
# 3. 创建指定类型的张量
def test03():
    # 前面创建的张量都是使用默认类型或者元素类型
    # 创建一个 int32 类型的张量
    data = torch.IntTensor(2, 3)
    print(data)
    # torch.ShortTensor(2, 3)  # 表示创建的是 int16 张量
    # torch.LongTensor(2, 3)  # 表示创建的是 int32 张量
    # torch.FloatTensor(2, 3)  # 表示创建的是 float32 张量
    # 注意: 如果创建指定类型的张量，但是传递的数据不匹配，会发生类型转换
    data = torch.IntTensor([2.5, 3.5])
    print(data)
if __name__ == '__main__':
    test03()

1.3 创建线性和随机张量

torch.arange 和 torch.linspace 创建线性张量
torch.random.init_seed 和 torch.random.manual_seed 随机种子设置
torch.randn 创建随机张量

import torch
# 1. 创建线性张量
def test01():
    # 1.1 创建指定步长的张量
    # 第一参数: 开始值
    # 第二参数: 结束值
    # 第三参数: 步长
    data = torch.arange(0, 10, 2)
    print(data)
    # 1.2 在指定区间指定元素个数
    # 第一个参数: 开始值
    # 第二个参数: 结束值
    # 第三个参数: 创建元素的个数
    data = torch.linspace(0, 11, 10)
    print(data)
    
# 2. 创建随机张量
def test02():
    # 固定随机数种子
    torch.random.manual_seed(0)
    
    # 2.1 创建随机张量
    data = torch.randn(2, 3)
    print(data)
    # 2.2 希望能够固定随机数
    print('随机数种子:', torch.random.initial_seed())
if __name__ == '__main__':
    test02()

1.4 创建全01张量

torch.ones 和 torch.ones_like 创建全1张量
torch.zeros 和 torch.zeros_like 创建全0张量
torch.full 和 torch.full_like 创建全为指定值张量

import torch
# 1. 创建全为0的张量
def test01():
    # 1.1 创建指定形状全为0的张量
    data = torch.zeros(2, 3)
    print(data)
    # 1.2 根据其他张量的形状去创建全0张量
    data = torch.zeros_like(data)
    print(data)
# 2. 创建全为1的张量
def test02():
    # 2.1 创建指定形状全为1的张量
    data = torch.ones(2, 3)
    print(data)
    # 2.2 根据其他张量的形状去创建全1张量
    data = torch.ones_like(data)
    print(data)
# 3. 创建全为指定值的张量
def test03():
    # 3.1 创建形状为2行3列，值全部为10的张量
    data = torch.full([2, 3], 100)
    print(data)
    # 3.2 创建一个形状和data一样，但是值全部为200的张量
    data = torch.full_like(data, 200)
    print(data)
if __name__ == '__main__':
    test03()

1.5 张量的类型转换

tensor.type(torch.DoubleTensor)
torch.double()

import torch
# 1. type 函数进行转换
def test01():
    data = torch.full([2, 3], 10)
    print(data.dtype)
    # 注意: 返回一个新的类型转换过的张量
    data = data.type(torch.DoubleTensor)
    print(data.dtype)
# 2. 使用具体类型函数进行转换
def test02():
    data = torch.full([2, 3], 10)
    print(data.dtype)
    # 转换成 float64 类型
    data = data.double()
    print(data.dtype)
    data = data.short()   # 将张量元素转换为 int16 类型
    data = data.int()   # 将张量转换为 int32 类型
    data = data.long()  # 将张量转换为 int64 类型
    data = data.float()  # 将张量转换为 float32
if __name__ == '__main__':
    test02()

1.6 小节

在本小节中，我们主要学习了以下内容：

创建张量的方式

torch.tensor 根据指定数据创建张量
torch.Tensor 根据形状创建张量, 其也可用来创建指定数据的张量
torch.IntTensor、torch.FloatTensor、torch.DoubleTensor 创建指定类型的张量

创建线性和随机张量

torch.arange 和 torch.linspace 创建线性张量
torch.random.init_seed 和 torch.random.manual_seed 随机种子设置
torch.randn 创建随机张量

创建01张量

torch.ones 和 torch.ones_like 创建全1张量
torch.zeros 和 torch.zeros_like 创建全0张量
torch.full 和 torch.full_like 创建全为指定值张量

张量元素类型转换

tensor.type(torch.DoubleTensor)
torch.double()

2. 张量的数值计算

2.1 张量基本运算

基本运算中，包括 add、sub、mul、div、neg 等函数, 以及这些函数的带下划线的版本 add_、sub_、mul_、div_、neg_，其中带下划线的版本为修改原数据。

import torch
# 1. 不修改原数据的计算
def test01():
    # 第一个参数: 开始值
    # 第二个参数: 结束值
    # 第三个参数: 形状
    data = torch.randint(0, 10, [2, 3])
    print(data)
    # 计算完成之后，会返回一个新的张量
    data = data.add(10)
    print(data)
    # data.sub()  # 减法
    # data.mul()  # 乘法
    # data.div()  # 除法
    # data.neg()  # 取相反数
# 2. 修改原数据的计算(inplace方式的计算)
def test02():
    data = torch.randint(0, 10, [2, 3])
    print(data)
    # 带下划线的版本的函数直接修改原数据，不需要用新的变量保存
    data.add_(10)
    print(data)
    # data.sub_()  # 减法
    # data.mul_()  # 乘法
    # data.div_()  # 除法
    # data.neg_()  # 取相反数
if __name__ == '__main__':
    test02()

2.2 阿达玛积

阿达玛积指的是矩阵对应位置的元素相乘. 可以使用乘号运算符、也可以使用 mul 函数来完成计算。

import torch
# 1. 使用 mul 函数
def test01():
    data1 = torch.tensor([[1, 2], [3, 4]])
    data2 = torch.tensor([[5, 6], [7, 8]])
    data = data1.mul(data2)
    print(data)
# 2. 使用 * 号运算符
def test02():
    data1 = torch.tensor([[1, 2], [3, 4]])
    data2 = torch.tensor([[5, 6], [7, 8]])
    data = data1 * data2
    print(data)
if __name__ == '__main__':
    test01()
    test02()

2.3 点积运算

点积运算要求第一个矩阵 shape: (n, m)，第二个矩阵 shape: (m, p), 两个矩阵点积运算 shape 为: (n, p)。

运算符 @ 用于进行两个矩阵的点乘运算
torch.mm 用于进行两个矩阵点乘运算, 要求输入的矩阵为2维
torch.bmm 用于批量进行矩阵点乘运算, 要求输入的矩阵为3维
torch.matmul 对进行点乘运算的两矩阵形状没有限定.

对于输入都是二维的张量相当于 mm 运算.
对于输入都是三维的张量相当于 bmm 运算
对数输入的 shape 不同的张量, 对应的最后几个维度必须符合矩阵运算规则

import torch
# 1. 使用 @ 运算符
def test01():
    # 形状为: 3行2列
    data1 = torch.tensor([[1, 2],
                          [3, 4],
                          [5, 6]])
    # 形状为: 2行2列
    data2 = torch.tensor([[5, 6],
                          [7, 8]])
    data = data1 @ data2
    print(data)
# 2. 使用 mm 函数
def test02():
    # 要求输入的张量形状都是二维
    # 形状为: 3行2列
    data1 = torch.tensor([[1, 2],
                          [3, 4],
                          [5, 6]])
    # 形状为: 2行2列
    data2 = torch.tensor([[5, 6],
                          [7, 8]])
    data = torch.mm(data1, data2)
    print(data)
# 3. 使用 bmm 函数
def test03():
    # 第一个维度: 表示批次
    # 第二个维度: 多少行
    # 第三个维度: 多少列
    data1 = torch.randn(3, 4, 5)
    data2 = torch.randn(3, 5, 8)
    
    data = torch.bmm(data1, data2)
    print(data.shape)
# 4. 使用 matmul 函数
def test04():
    # 对二维进行计算
    data1 = torch.randn(4, 5)
    data2 = torch.randn(5, 8)
    print(torch.matmul(data1, data2).shape)
    
    # 对三维进行计算
    data1 = torch.randn(3, 4, 5)
    data2 = torch.randn(3, 5, 8)
    print(torch.matmul(data1, data2).shape)
    data1 = torch.randn(3, 4, 5)
    data2 = torch.randn(5, 8)
    print(torch.matmul(data1, data2).shape)
if __name__ == '__main__':
    test04()

2.4 指定设备运算

PyTorch 默认会将张量创建在 CPU 控制的内存中, 即: 默认的运算设备为 CPU。我们也可以将张量创建在 GPU 上, 能够利用对于矩阵计算的优势加快模型训练。将张量移动到 GPU 上有两种方法:

使用 cuda 方法
直接在 GPU 上创建张量
使用 to 方法指定设备

import torch
# 1. 使用 cuda 方法
def test01():
    data = torch.tensor([10, 20, 30])
    print('存储设备:', data.device)
    # 将张量移动到 GPU 设备上
    data = data.cuda()
    print('存储设备:', data.device)
    # 将张量从GPU再移动到CPU
    data = data.cpu()
    print('存储设备:', data.device)
# 2. 直接将张量创建在指定设备上
def test02():
    data = torch.tensor([10, 20, 30], device='cuda:0')
    print('存储设备:', data.device)
    # 把张量移动到cpu设备上
    data = data.cpu()
    print('存储设备:', data.device)
# 3. 使用 to 方法
def test03():
    data = torch.tensor([10, 20, 30])
    print('存储设备:', data.device)
    # 使用 to 方法移动张量到指定设备
    data = data.to('cuda:0')
    print('存储设备:', data.device)
# 4. 注意: 存储在不同设备上的张量不能够直接运算
def test04():
    data1 = torch.tensor([10, 20, 30])
    data2 = torch.tensor([10, 20, 30], device='cuda:0')
    # RuntimeError: Expected all tensors to be on the same device, but found at least two devices, cuda:0 and cpu!
    # 下面代码会报错
    # 如果你的电脑上安装 pytorch 不是 gpu 版本的，或者电脑本身没有 gpu (nvidia)设备环境
    # 否则下面的调用 cuda 函数的代码会报错
    data1 = data1.cuda()
    data = data1 + data2
    print(data)
if __name__ == '__main__':
    test04()

2.5 小节

在本小节中，我们主要学习的主要内容如下:

张量基本运算函数 add、sub、mul、div、neg 等函数, add、sub、mul、div、neg_ 等 inplace 函数
张量的阿达玛积运算 mul 和运算符 * 的用法
点积运算:

运算符 @ 用于进行两个矩阵的点乘运算
torch.mm 用于进行两个矩阵点乘运算, 要求输入的矩阵为2维
torch.bmm 用于批量进行矩阵点乘运算, 要求输入的矩阵为3维
torch.matmul 对进行点乘运算的两矩阵形状没有限定.

对于输入都是二维的张量相当于 mm 运算.
对于输入都是三维的张量相当于 bmm 运算
对数输入的 shape 不同的张量, 对应的最后几个维度必须符合矩阵运算规则

将变量移动到 GPU 设备的方法，例如: cuda 方法、直接在 GPU 上创建张量、使用 to 方法指定设备

探索PyTorch：张量的创建和数值计算