↓跳过正文
TakeEZ

PyTorch系列 - 基础入门

··3260 字·
深度学习 PyTorch
EZ
作者
EZ
Take it EZ!
目录
PyTorch - 这篇文章属于一个选集。
§ 1: PyTorch系列 - 环境配置
§ 2: 本文

在这篇博客中，我们将了解 PyTorch 的基础知识，包括张量（Tensor）、其操作以及一些常见的功能。

  • 检查 PyTorch 版本 
    import torch
print(torch.__version__)
  • 输出 
    2.3.1

1. 张量基础
#

张量是 PyTorch 的基本数据结构。它类似于 NumPy 的数组，但具有更强的灵活性，可以在 GPU 上进行计算。

1.1. 标量
#

标量是仅包含一个数字的张量。

scalar = torch.tensor(7)
print(f'标量的维度: {scalar.ndim}')
print(f'标量的值: {scalar.item()}')
  • 输出
标量的维度: 0
标量的值: 7

1.2. 向量
#

向量是包含一维数组的张量。

vector = torch.tensor([7, 7])
print(f'向量的维度: {vector.ndim}')
print(f'向量的形状: {vector.shape}')
  • 输出
向量的维度: 1
向量的形状: torch.Size([2])

1.3. 矩阵
#

矩阵是包含二维数组的张量。

MATRIX = torch.tensor([[7, 8],
                       [9, 10]])
print(f'矩阵的维度: {MATRIX.ndim}')
print(f'矩阵的形状: {MATRIX.shape}')
print(f'矩阵的第一个元素: {MATRIX[0]}')
  • 输出
矩阵的维度: 2
矩阵的形状: torch.Size([2, 2])
矩阵的第一个元素: tensor([7, 8])

1.4. 张量
#

张量可以包含多维数组。

TENSOR = torch.tensor([[[1, 2, 3],
                        [4, 5, 6],
                        [7, 8, 9]]])
print(f'张量的维度: {TENSOR.ndim}')
print(f'张量的形状: {TENSOR.shape}')
print(f'张量的第一个元素: {TENSOR[0]}')
  • 输出
张量的维度: 3
张量的形状: torch.Size([1, 3, 3])
张量的第一个元素: tensor([[1, 2, 3],
                       [4, 5, 6],
                       [7, 8, 9]])

1.5. 随机张量
#

可以生成具有随机值的张量。

random_tensor_1 = torch.rand(3, 4)
print(f'随机张量1: \n{random_tensor_1}')
print(f'随机张量1的维度: {random_tensor_1.ndim}')

random_tensor_2 = torch.rand(1, 3, 4)
print(f'随机张量2: \n{random_tensor_2}')
print(f'随机张量2的维度: {random_tensor_2.ndim}')

random_image_size_tensor = torch.rand(size=(3, 224, 224))
print(f'随机图像大小张量的形状: {random_image_size_tensor.shape}')
print(f'随机图像大小张量的维度: {random_image_size_tensor.ndim}')
  • 输出
随机张量1: 
tensor([[0.7991, 0.2205, 0.0756, 0.4336],
        [0.9969, 0.7590, 0.8756, 0.2459],
        [0.3081, 0.7802, 0.6533, 0.7085]])
随机张量1的维度: 2
随机张量2: 
tensor([[[0.8909, 0.6000, 0.7818, 0.1763],
         [0.9720, 0.0850, 0.1388, 0.9637],
         [0.8513, 0.6557, 0.7406, 0.8667]]])
随机张量2的维度: 3
随机图像大小张量的形状: torch.Size([3, 224, 224])
随机图像大小张量的维度: 3

1.6. 全零和全一张量
#

可以生成全零或全一的张量。

zeros = torch.zeros(size=(3, 4))
print(f'全零张量: \n{zeros}')

ones = torch.ones(size=(3, 4))
print(f'全一张量: \n{ones}')
print(f'全一张量的数据类型: {ones.dtype}')
  • 输出
全零张量: 
tensor([[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]])
全一张量: 
tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]])
全一张量的数据类型: torch.float32

2. 张量运算
#

张量可以进行各种运算。

2.1. 基础运算
# 

tensor = torch.tensor([1, 2, 3])
print(f'张量 + 10: {tensor + 10}')
print(f'张量 * 10: {tensor * 10}')
print(f'张量 - 10: {tensor - 10}')

# 使用 PyTorch 内置函数
print(f'张量乘法: {torch.mul(tensor, 10)}')
print(f'张量加法: {torch.add(tensor, 10)}')

# 元素级乘法
print(f'元素级乘法: {tensor * tensor}')

# 矩阵乘法
print(f'矩阵乘法: {torch.matmul(tensor, tensor)}')
print(f'矩阵乘法 (使用@运算符): {tensor @ tensor}')
  • 输出
张量 + 10: tensor([11, 12, 13])
张量 * 10: tensor([10, 20, 30])
张量 - 10: tensor([-9, -8, -7])
张量乘法: tensor([10, 20, 30])
张量加法: tensor([11, 12, 13])
元素级乘法: tensor([1, 4, 9])
矩阵乘法: 14
矩阵乘法 (使用@运算符): 14

2.2. 矩阵操作
# 

tensor_A = torch.tensor([[1, 2],
                         [3, 4],
                         [5, 6]])
tensor_B = torch.tensor([[7, 10],
                         [8, 11],
                         [9, 12]])

print(f'tensor_B 转置: \n{tensor_B.T}')
print(f'矩阵乘法: \n{torch.matmul(tensor_A, tensor_B.T)}')
  • 输出
tensor_B 转置: 
tensor([[ 7,  8,  9],
        [10, 11, 12]])
矩阵乘法: 
tensor([[ 27,  30,  33],
        [ 61,  68,  75],
        [ 95, 106, 117]])

2.3. 张量聚合
# 

x = torch.arange(0, 100, 10)
print(f'张量: {x}')
print(f'数据类型: {x.dtype}')

# 最小值
print(f'最小值: {torch.min(x)}')

# 最大值
print(f'最大值: {torch.max(x)}')

# 平均值
print(f'平均值: {torch.mean(x.type(torch.float32))}')

# 求和
print(f'求和: {torch.sum(x)}')

# 最小值索引
print(f'最小值索引: {x.argmin()}')

# 最大值索引
print(f'最大值索引: {x.argmax()}')
  • 输出
张量: tensor([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
数据类型: torch.int64
最小值: 0
最大值: 90
平均值: 45.0
求和: 450
最小值索引: 0
最大值索引: 9

2.4. 张量变形
# 

x = torch.arange(1., 10.)
print(f'原张量: {x}, 形状: {x.shape}')

x_reshaped = x.reshape(3, 3)
print(f'变形后的张量: {x_reshaped}, 形状: {x_reshaped.shape}')
  • 输出
原张量: tensor([1., 2., 3., 4., 5., 6., 7., 8., 9.]), 形状: torch.Size([9])
变形后的张量: tensor([[1., 2., 3.],
                    [4., 5., 6.],
                    [7., 8., 9.]]), 形状: torch.Size([3, 3])

2.5. view 函数
#

  • view 函数是 PyTorch 中用于张量（Tensor）变形（reshape）的一种方法。它可以改变张量的形状，但不会改变其数据。
  • view 返回的张量与原始张量共享相同的数据。这意味着改变其中一个张量的数据会影响另一个张量。这是因为 view 仅仅是改变了张量的视图，而没有改变其底层的数据存储。
z = x.view(1, 9)
print(f'查看张量: {z}, 形状: {z.shape}')
z[:, 0] = 5
print(f'修改后的查看张量: {z}')
print(f'原张量: {x}')
  • 输出
查看张量: tensor([[1., 2., 3., 4., 5., 6., 7., 8., 9.]]), 形状: torch.Size([1, 9])
修改后的查看张量: tensor([[5., 2., 3., 4., 5., 6., 7., 8., 9.]])
原张量: tensor([5., 2., 3., 4., 5., 6., 7., 8., 9.])
  • 由于 view 不会复制数据，所以它比 reshape 更高效。然而，如果需要对张量进行大量变形操作，需要考虑张量的连续性问题。
  • view 函数要求张量在内存中是连续的。如果张量在内存中不是连续存储的，可以使用 contiguous() 方法将其转换为连续存储。
y = torch.arange(1, 10).view(3, 3)
z = y.transpose(0, 1)  # 转置操作使张量不再连续
print(z.is_contiguous())  # 输出 False

z_contiguous = z.contiguous()
print(z_contiguous.is_contiguous())  # 输出 True

2.6. 堆叠张量
# 

x_stacked_0 = torch.stack([x, x, x, x], dim=0)
x_stacked_1 = torch.stack([x, x, x, x], dim=1)
print(f'堆叠张量 (dim=0): \n{x_stacked_0}')
print(f'堆叠张量 (dim=1): \n{x_stacked_1}')
  • 输出
堆叠张量 (dim=0): 
tensor([[5., 2., 3., 4., 5., 6., 7., 8., 9.],
        [5., 2., 3., 4., 5., 6., 7., 8., 9.],
        [5., 2., 3., 4., 5., 6., 7., 8., 9.],
        [5., 2., 3., 4., 5., 6., 7., 8., 9.]])
堆叠张量 (dim=1): 
tensor([[5., 5., 5., 5.],
        [2., 2., 2., 2.],
        [3., 3., 3., 3.],
        [4., 4., 4., 4.],
        [5., 5., 5., 5.],
        [6., 6., 6., 6.],
        [7., 7., 7., 7.],
        [8., 8., 8., 8.],
        [9., 9., 9., 9.]])

2.7. 紧缩和扩展张量
# 

x_reshaped = x.reshape(1, 9)
print(f'变形后的张量: {x_reshaped}, 形状: {x_reshaped.shape}')
x_squeezed = x_reshaped.squeeze()
print(f'紧缩后的张量: {x_squeezed}, 形状: {x_squeezed.shape}')

x_unsqueezed = x_squeezed.unsqueeze(dim=0)
print(f'扩展后的张量 (dim=0): {x_unsqueezed}, 形状: {x_unsqueezed.shape}')
x_unsqueezed = x_squeezed.unsqueeze(dim=1)
print(f'扩展后的张量 (dim=1): {x_unsqueezed}, 形状: {x_unsqueezed.shape}')
  • 输出
变形后的张量: tensor([[5., 2., 3., 4., 5., 6., 7., 8., 9.]]), 形状: torch.Size([1, 9])
紧缩后的张量: tensor([5., 2., 3., 4., 5., 6., 7., 8., 9.]), 形状: torch.Size([9])
扩展后的张量 (dim=0): tensor([[5., 2., 3., 4., 5., 6., 7., 8., 9.]]), 形状: torch.Size([1, 9])
扩展后的张量 (dim=1): tensor([[5.],
        [2.],
        [3.],
        [4.],
        [5.],
        [6.],
        [7.],
        [8.],
        [9.]]), 形状: torch.Size([9, 1])

2.8. 张量排列
# 

x_original = torch.rand(size=(224, 224, 3))
x_permuted = torch.permute(x_original, (2, 0, 1))
print(f'原张量形状: {x_original.shape}, 调整后的张量形状: {x_permuted.shape}')
  • 输出
原张量形状: torch.Size([224, 224, 3]), 调整后的张量形状: torch.Size([3, 224, 224])

2.9. 张量索引
# 

x = torch.arange(1, 10).reshape(1, 3, 3)
print(f'张量: \n{x}, 形状: {x.shape}')
print(f'索引 [0]: {x[0]}')
print(f'索引 [0, 0]: {x[0][0]}')
print(f'索引 [0, 0, 0]: {x[0, 0, 0]}')
print(f'索引 [:, 0]: {x[:, 0]}')
print(f'索引 [:, :, 0]: {x[:, :, 0]}')
print(f'索引 [:, :, 1]: {x[:, :, 1]}')
print(f'索引 [:, :, 0:2]: {x[:, :, 0:2]}')
  • 输出
张量: 
tensor([[[1, 2, 3],
         [4, 5, 6],
         [7, 8, 9]]]), 形状: torch.Size([1, 3, 3])
索引 [0]: tensor([[1, 2, 3],
                 [4, 5, 6],
                 [7, 8, 9]])
索引 [0, 0]: tensor([1, 2, 3])
索引 [0, 0, 0]: 1
索引 [:, 0]: tensor([[1, 2, 3]])
索引 [:, :, 0]: tensor([[1, 4, 7]])
索引 [:, :, 1]: tensor([[2, 5, 8]])
索引 [:, :, 0:2]: tensor([[[1, 2],
                          [4, 5],
                          [7, 8]]])

2.10. 与 NumPy 的互换
#

  • NumPy 到 Tensor
import numpy as np
import torch

array = np.arange(1.0, 8.0)
tensor = torch.from_numpy(array)
print(f'NumPy 数组: {array}, 数据类型: {array.dtype}')
print(f'Tensor: {tensor}, 数据类型: {tensor.dtype}')
  • 输出
NumPy 数组: [1. 2. 3. 4. 5. 6. 7.], 数据类型: float64
Tensor: tensor([1., 2., 3., 4., 5., 6., 7.], dtype=torch.float64), 数据类型: torch.float64
  • Tensor 到 NumPy
tensor = torch.ones(7)
numpy_tensor = tensor.numpy()
print(f'Tensor: {tensor}')
print(f'NumPy 数组: {numpy_tensor}')
  • 输出
Tensor: tensor([1., 1., 1., 1., 1., 1., 1.])
NumPy 数组: [1. 1. 1. 1. 1. 1. 1.]

2.11. 可重复性
# 

random_tensor_A = torch.rand(3, 4)
random_tensor_B = torch.rand(3, 4)
print(f'随机张量 A 和 B 是否相等: {random_tensor_A == random_tensor_B}')

RANDOM_SEED = 42
torch.manual_seed(RANDOM_SEED)
random_tensor_C = torch.rand(3, 4)
torch.manual_seed(RANDOM_SEED)
random_tensor_D = torch.rand(3, 4)
print(f'随机张量 C 和 D 是否相等: {random_tensor_C == random_tensor_D}')
  • 输出
随机张量 A 和 B 是否相等: tensor([[False, False, False, False],
                                [False, False, False, False],
                                [False, False, False, False]])
随机张量 C 和 D 是否相等: tensor([[True, True, True, True],
                                [True, True, True, True],
                                [True, True, True, True]])

3. 使用 GPU
#

我们可以使用 Google Colab 来体验在 GPU 上运行代码。创建一个 .ipynb 文件后，点击页面顶部的 “代码执行程序” 菜单，然后选择 “更改运行时类型”，在弹出的对话框中选择 “硬件加速器”为 GPU，即可。

  • 检查是否有可用的 GPU
import torch
print(torch.cuda.is_available())
  • 输出
True
  • 在 notebook 里查看 GPU 信息
!nvidia-smi
  • 输出
+---------------------------------------------------------------------------------------+
| NVIDIA-SMI 535.104.05             Driver Version: 535.104.05   CUDA Version: 12.2     |
|-----------------------------------------+----------------------+----------------------+
| GPU  Name                 Persistence-M | Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |         Memory-Usage | GPU-Util  Compute M. |
|                                         |                      |               MIG M. |
|=========================================+======================+======================|
|   0  Tesla T4                       Off | 00000000:00:04.0 Off |                    0 |
| N/A   45C    P8              10W /  70W |      3MiB / 15360MiB |      0%      Default |
|                                         |                      |                  N/A |
+-----------------------------------------+----------------------+----------------------+
                                                                                         
+---------------------------------------------------------------------------------------+
| Processes:                                                                            |
|  GPU   GI   CI        PID   Type   Process name                            GPU Memory |
|        ID   ID                                                             Usage      |
|=======================================================================================|
|  No running processes found                                                           |
+---------------------------------------------------------------------------------------+
  • 将张量从 CPU 移动到 GPU
device = "cuda" if torch.cuda.is_available() else "cpu"
print(f'使用的设备: {device}')

# 检查 GPU 的数量
print(f'可用 GPU 数量: {torch.cuda.device_count()}')

tensor = torch.tensor([1, 2, 3])
print(f'张量: {tensor}, 设备: {tensor.device}')

tensor_on_gpu = tensor.to(device)
print(f'在 GPU 上的张量: {tensor_on_gpu}')

tensor_back_on_cpu = tensor_on_gpu.cpu()
print(f'移回 CPU 的张量: {tensor_back_on_cpu}')
  • 输出
使用的设备: cuda
可用 GPU 数量: 1 (或其他数字，取决于你系统上的 GPU 数量)
张量: tensor([1, 2, 3]), 设备: cpu
在 GPU 上的张量: tensor([1, 2, 3], device='cuda:0')
移回 CPU 的张量: tensor([1, 2, 3])
PyTorch - 这篇文章属于一个选集。
§ 1: PyTorch系列 - 环境配置
§ 2: 本文

相关文章

PyTorch系列 - 环境配置
··864 字
深度学习 PyTorch
本文介绍如何在 Mac 上安装 PyTorch，并利用 Apple 芯片的 Metal 框架进行加速。
深度学习-基础知识
·1488 字
深度学习
持续更新中…
XGBoost
··4566 字
机器学习 XGBoost GBDT
XGBoost（eXtreme Gradient Boosting）是一种基于梯度提升（Gradient Boosting）的机器学习算法。
随机森林
·3325 字
机器学习 随机森林
随机森林（Random Forest）是一种常用的集成学习方法。
线性回归与逻辑回归
·3406 字
机器学习 统计学习 线性回归 逻辑回归
本文详细介绍了线性回归和逻辑回归的基本概念、假设、目标、模型评价指标、多重共线性问题以及评估指标。
Spark系列 - 数据合并
·2309 字
大数据 Spark DataFrame
本文介绍了 Spark 中的几种常见 Join 操作，包括 Inner Join、Outer Join、Left Join 和 Right Join，以及它们的具体实现和优化方法。