PyTorch学习总结（一）

PyTorch

PyTorch是由faceBook人工智能研究院开发的开源深度学习框架，具有以下特点：

动态计算图：便于调试和实验
Python优先：易学易用
强大的GPU加速：支持CUDA
活跃的社区：丰富的教程和预训练模型

配置环境

安装

bash 复制代码

# 使用pip安装（CPU版本）
pip install torch torchvision torchaudio

# 使用conda安装
conda install pytorch torchvision torchaudio -c pytorch

# 查看是否安装成功
python -c "import torch; print(torch.__version__)"

验证安装

python 复制代码

import torch

# 检查PyTorch版本
print(f"PyTorch版本: {torch.__version__}")

# 检查CUDA是否可用
print(f"CUDA是否可用: {torch.cuda.is_available()}")

# 如果有GPU，显示GPU信息
if torch.cuda.is_available():
    print(f"GPU数量: {torch.cuda.device_count()}")
    print(f"当前GPU: {torch.cuda.current_device()}")
    print(f"GPU名称: {torch.cuda.get_device_name(0)}")

基础概念

PyTorch的基础概念包括张量（Tensors）、自动微分（Autograd）、神经网络（Neural Networks）等。

1. 张量（Tensors）

张量是PyTorch中最基本的数据结构，类似于多维数组。

标量（Scalar）：0维张量，只有一个值
向量（Vector）：1维张量，有多个值
矩阵（Matrix）：2维张量，有多个向量
高维张量：3维及以上张量，有多个矩阵

属性

形状（Shape）：张量的维度大小
数据类型（dtype）：张量中元素的类型，如float32、int64等
设备（device）：张量所在的计算设备，如CPU或GPU
梯度（grad）：张量的梯度，只有当 requires_grad=True 时才会计算（requires_grad 默认False）

运算

算术运算：加法、减法、乘法、除法等
矩阵操作：矩阵乘法、转置、索引、切片等
线性代数运算：矩阵求逆、行列式、特征值、特征向量等

创建

从Python列表或NumPy数组创建
使用torch.tensor()函数创建
使用torch.rand()、torch.randn()、torch.zeros()等函数创建随机张量或全0张量

示例

python 复制代码

 import torch

  # 创建张量
  x = torch.tensor([1, 2, 3, 4])          # 一维张量
  y = torch.tensor([[1, 2], [3, 4]])      # 二维张量
  z = torch.zeros(2, 3)                   # 全零张量
  w = torch.ones(2, 3, 4)                 # 全一张量
  r = torch.rand(3, 3)                    # 随机张量

  # 张量属性
  print(f"形状: {x.shape}")
  print(f"数据类型: {x.dtype}")
  print(f"设备: {x.device}")

  # 张量运算
  a = torch.tensor([1, 2, 3])
  b = torch.tensor([4, 5, 6])

  print(f"加法: {a + b}")
  print(f"乘法: {a * b}")
  print(f"点积: {torch.dot(a, b)}")
  print(f"矩阵乘法: {torch.matmul(a.reshape(3,1), b.reshape(1,3))}")

  # 改变形状
  tensor = torch.arange(12)
  print(f"原始形状: {tensor.shape}")
  print(f"重塑为3x4: {tensor.reshape(3, 4).shape}")
  print(f"转置: {tensor.reshape(3, 4).T.shape}")

2. 自动微分（Autograd）

自动微分是PyTorch中实现反向传播的机制，用于计算损失函数关于模型参数的梯度。

计算图（Computation Graph）：将模型的前向传播过程表示为一个有向无环图（DAG），每个节点表示一个张量或操作。
前向传播（Forward Pass）：从输入层开始，根据计算图进行前向计算，得到输出层的张量。
反向传播（Backward Pass）：从输出层开始，根据计算图进行反向计算，计算每个节点对损失函数的梯度。
梯度计算（Gradient Computation）：利用链式法则，将损失函数关于每个参数的梯度计算出来。

示例

python 复制代码

  # 创建需要梯度的张量
x = torch.tensor(2.0, requires_grad=True)
y = torch.tensor(3.0, requires_grad=True)

# 进行计算
z = x**2 + y**3

# 反向传播计算梯度
z.backward()

print(f"dz/dx = {x.grad}")  # 2x = 4
print(f"dz/dy = {y.grad}")  # 3y^2 = 27

# 更复杂的例子
x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
y = x**2 + 2*x + 1
y.sum().backward()
print(f"梯度: {x.grad}")

3. 神经网络（nn.Module）

神经网络是一种模拟人脑神经元工作原理的计算模型，用于解决复杂的模式识别和预测问题。

神经网络的基本组成部分

输入层（Input Layer）：接收外部输入数据
隐藏层（Hidden Layers）：多个神经元层，每个神经元接收前一层的输出，进行加权求和和激活函数处理
输出层（Output Layer）：产生最终的输出结果

神经网络的训练过程

前向传播（Forward Propagation）：输入数据通过神经网络，计算出输出结果
损失计算（Loss Calculation）：将输出结果与真实标签进行比较，计算损失值
反向传播（Backward Propagation）：利用自动微分，计算损失函数关于每个参数的梯度
梯度下降（Gradient Descent）：根据梯度更新参数，最小化损失函数

示例

python 复制代码

 import torch
 import torch.nn as nn
 import torch.nn.functional as F

 # 定义一个简单的神经网络
 class SimpleNet(nn.Module):
     def __init__(self):
         super(SimpleNet, self).__init__()
         self.fc1 = nn.Linear(2, 4)  # 输入层到隐藏层，2个输入特征，4个神经元
         self.fc2 = nn.Linear(4, 1)  # 隐藏层到输出层，4个神经元，1个输出特征

     def forward(self, x):
         x = F.relu(self.fc1(x))  # 隐藏层使用ReLU激活函数
         x = self.fc2(x)          # 输出层不使用激活函数
         return x

 # 创建神经网络实例
 net = SimpleNet()
 print(net)