Python Torch 函数学习

hnmpf

于 2025-03-08 15:01:28 发布

阅读量634

点赞数 8

文章标签： python 学习开发语言

本文链接：https://blog.youkuaiyun.com/hnmpf/article/details/146113511

版权

1、Torch.nn

提供了多种神经网络层，用户可以通过它来构建网络

全链路层：torch.nn.Linear

torch.nn.Linear(in_features=10, out_features=5)

测试：
### 手写数字识别模型算法实现。
###
import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt


# 定义神经网络
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(5 * 5, 11)  # 输入层到隐藏层
        self.fc2 = nn.Linear(11, 5)       # 隐藏层到输出层

    def forward(self, x):
        print('0:',x)
        x = x.view(-1, 5 * 5)  # 展平输入
        print('1:',x.numpy())
        plt.plot(x.numpy(),x.numpy(), label='Random Data')
        print('fc1:',self.fc1)
        fc1v = self.fc1(x)
        print('fc1v.size:',fc1v.size())
        print('4',fc1v)

        x = torch.relu(fc1v)  # 激活函数ReLU
        print('2:',x)
        x = self.fc2(x)
        print('3:',x)
        return x


# 创建模型实例
model = SimpleNN()

# 定义损失函数（交叉熵损失，用于分类任务）
criterion = nn.CrossEntropyLoss()
# 定义优化器（随机梯度下降优化器）
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 示例输入
input = torch.randn(5, 5)  # 随机生成一个28x28的输入
print('输入：', input)
output = model(input)  # 前向传播
print('第一层输出：', output)
loss = criterion(output, torch.tensor([4]))  # 假设真实标签为3

# 反向传播和优化
optimizer.zero_grad()
loss.backward()
optimizer.step()

print("输出：", output)
print("损失：", loss.item())

卷积层：`torch.nn.Conv2d`, `torch.nn.Conv1d`, `torch.nn.Conv3d`

conv_layer = torch.nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1)

用于卷积操作，广泛应用于卷积神经网络（CNN）

池化层：`torch.nn.MaxPool2d`, `torch.nn.AvgPool2d`

max_pool = torch.nn.MaxPool2d(kernel_size=2, stride=2)

用于池化操作，常用于 CNN 网络中，帮助降低特征图的尺寸。

循环层：`torch.nn.RNN`, `torch.nn.LSTM`, `torch.nn.GRU`

rnn_layer = torch.nn.RNN(input_size=10, hidden_size=20, num_layers=2)

用于构建循环神经网络（RNN），LSTM 和 GRU 是特殊的 RNN 单元

自注意力层（Transformer）：torch.nn.Transformer

transformer_layer = torch.nn.Transformer(d_model=512, nhead=8, num_encoder_layers=6)

用于构建 Transformer 网络，广泛应用于自然语言处理任务

激活函数层：`torch.nn.ReLU（斜坡函数）`, `torch.nn.Sigmoid（逻辑）`, `torch.nn.Tanh（双曲线）`

relu = torch.nn.ReLU()

import numpy as np
import torch.nn as nn
import matplotlib.pyplot as plt
import torch

# 线型变换
# 3：每个输入样板的特征是3
# 2：每个输出样本的特征是1
model = nn.Linear(3, 4)
# 输入的样本
input = torch.Tensor([[2, 4, 6], [3, 2, 5], [6, 2, 8], [6, 7, 3]])
output = model(input)
plt.plot(output.detach().numpy())

print(output.size())
print(output)

reLuv = torch.relu(output)

print(reLuv)

print("查看模型参数W和b的值")
# 查看模型参数
for param in model.parameters():
    print(param)

plt.ylabel('numbers')
plt.show()

Dropout层：torch.nn.Dropout

dropout = torch.nn.Dropout(p=0.5)

正则化技术，防止过拟合

2、损失函数（Loss）---衡量模型预测值与实际值之间差异程度的函数

交叉熵损失：torch.nn.CrossEntropyLoss

在分类问题中，模型会输出一个概率分布，表示样本属于各个类别的概率，而交叉熵损失则通过比较这个预测分布与真实分布来计算损失

loss_fn = torch.nn.CrossEntropyLoss()
loss = loss_fn(predictions, labels)

均方误差损失：torch.nn.MSELoss

通过计算预测值与实际值之间差的平方的平均值来得出

loss_fn = torch.nn.MSELoss()
loss = loss_fn(predictions, labels)

均方根误差损失：torch.nn.RMSELoss

通过计算预测值与实际值之间差的平方的平均值的平方根来衡量的

负对数似然损失：torch.nn.NLLLoss

计算了模型预测的概率分布与实际标签的概率分布之间的对数差异

loss_fn = torch.nn.NLLLoss()
loss = loss_fn(predictions, labels)

二元交叉熵损失：torch.nn.BCEWithLogitsLoss

loss_fn = torch.nn.BCEWithLogitsLoss()
loss = loss_fn(predictions, labels)

损失函数的作用：

1、损失函数提供了评估模型性能的方法。通过比较不同模型的损失值，我们可以选择性能最佳的模型

2、在训练过程中，损失函数用于指导参数的更新。通过反向传播算法，我们可以计算出损失函数关于模型参数的梯度，并使用优化算法（如梯度下降）来更新参数，从而最小化损失函数。

3、有时，我们会在损失函数中加入正则化项（如L1正则化或L2正则化），以防止模型过拟合。正则化项通过惩罚模型参数的复杂度来限制模型的复杂度，从而提高模型的泛化能力

3、`Module`

构建神经网络模型时，我们通常会继承 torch.nn.Module 类并实现其 forward 方法。torch.nn.Module 是 PyTorch 中所有神经网络模块的基类，提供了模型的基础功能，如参数的管理、网络前向传播等

### 手写数字识别模型算法实现。
###
import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt


# 定义神经网络
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(5 * 5, 11)  # 输入层到隐藏层
        self.fc2 = nn.Linear(11, 5)       # 隐藏层到输出层

    def forward(self, x):
        print('0:',x)
        x = x.view(-1, 5 * 5)  # 展平输入
        print('1:',x.numpy())
        plt.plot(x.numpy(),x.numpy(), label='Random Data')
        print('fc1:',self.fc1)
        fc1v = self.fc1(x)
        print('fc1v.size:',fc1v.size())
        print('4',fc1v)

        x = torch.relu(fc1v)  # 激活函数ReLU
        print('2:',x)
        x = self.fc2(x)
        print('3:',x)
        return x


# 创建模型实例
model = SimpleNN()

# 定义损失函数（交叉熵损失，用于分类任务）
criterion = nn.CrossEntropyLoss()
# 定义优化器（随机梯度下降优化器）
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 示例输入
input = torch.randn(5, 5)  # 随机生成一个28x28的输入
print('输入：', input)
output = model(input)  # 前向传播
print('第一层输出：', output)
loss = criterion(output, torch.tensor([4]))  # 假设真实标签为3

# 反向传播和优化
optimizer.zero_grad()
loss.backward()
optimizer.step()

print("输出：", output)
print("损失：", loss.item())



plt.show()

注意：

一般把网络中具有可学习参数的层（如全连接层、卷积层）放在构造函数 __init__() 中
forward() 方法必须重写，它是实现模型的功能，实现各个层之间连接关系的核心
初始化 (init)：

初始化（init）:

在类的初始化方法中定义并实例化所有需要的层、参数和其他组件。在实现自己的MyModel类时继承了nn.Module，在构造函数中要调用Module的构造函数 super(MyModel,self).init()

前向传播 (forward)：

实现前向传播函数来描述输入数据如何通过网络产生输出结果。因为parameters是自动求导，所以调用forward()后，不用自己写和调用backward()函数。而且一般不是显式的调用forward(layer.farword)，而是layer(input)，会自执行forward()

管理参数和模块:

.parameters() 访问模型的所有可学习参数

# 查看模型参数
for param in model.parameters():
    print(param)

add_module() 添加子模块，并给它们命名以便于访问

register_buffer() 为模型注册非可学习的缓冲区变量

训练与评估模式切换

model.train()

将模型设置为训练模式，这会影响某些层的行为，如批量归一化层和丢弃层

model.eval()

将模型设置为评估模式，此时会禁用这些依赖于训练阶段的行为

保存和加载模型状态

model.state_dict()

获取模型权重和优化器状态的字典形式

torch.save() 和 torch.load()

来保存和恢复整个模型或者仅其状态字典。

model.load_state_dict(state_dict)

加载先前保存的状态字典到模型中

文章参考：

2、https://blog.youkuaiyun.com/lzm12278828/article/details/144024471

1、https://blog.youkuaiyun.com/u013172930/article/details/145706828

3、PyTorch之nn.Module、nn.Sequential、nn.ModuleList使用详解-优快云博客