神经网络构建与训练深度学习模型全过程（PyTorch & TensorFlow）

🕗 发布于 2024-10-19 05:53 深度学习 神经网络 pytorch 人工智能 机器学习

神经网络构建与训练深度学习模型全过程（PyTorch & TensorFlow）

🔗 什么是神经网络：基础架构与工作原理
🧩 构建简单的神经网络：层次结构与激活函数
🚀 前向传播：神经网络的数据流动
🎯 损失函数与代价函数：神经网络的误差度量
🔄 反向传播算法：模型的参数优化机制
🛠️ 常见优化器解析：从梯度下降到自适应优化
🧠 实战：训练与调优深度神经网络模型
📊 结果评估与模型调试：准确率与过拟合问题分析

1. 🔗 什么是神经网络：基础架构与工作原理

神经网络（Neural Network）是一种模拟人脑神经元的数学模型，其目的是通过模拟神经元之间的连接与传递信息的方式，来完成复杂的数据处理任务。神经网络由若干层神经元组成，通常分为输入层、隐藏层和输出层。

神经元：
每个神经元接收输入信号，并经过激活函数处理后产生输出信号，输出信号又成为下一层神经元的输入。每个连接上的权重决定了输入的重要性，而偏置（bias）则用于调整神经元的输出。

工作原理：
当输入层接收数据后，信息通过权重矩阵传递到隐藏层，并在此处进行复杂的计算与转换。激活函数是确保模型可以捕获非线性关系的关键，常见的激活函数包括ReLU、Sigmoid和Tanh。最终，输出层产生预测结果，模型根据这些结果和真实标签之间的误差来调整权重。

PyTorch实现：

import torch
import torch.nn as nn

# 定义简单的神经网络架构
class SimpleNeuralNetwork(nn.Module):
    def __init__(self):
        super(SimpleNeuralNetwork, self).__init__()
        self.layer1 = nn.Linear(10, 5)  # 输入层10维，输出5维
        self.layer2 = nn.Linear(5, 2)   # 隐藏层5维，输出2维

    def forward(self, x):
        x = torch.relu(self.layer1(x))  # 使用ReLU激活函数
        x = self.layer2(x)              # 输出层不需要激活函数
        return x

# 创建模型实例并输出网络结构
model = SimpleNeuralNetwork()
print(model)

TensorFlow实现：

import tensorflow as tf
from tensorflow.keras import layers, models

# 定义简单的神经网络架构
model = models.Sequential([
    layers.Dense(5, activation='relu', input_shape=(10,)),  # 输入层10维，输出5维
    layers.Dense(2)  # 输出层2维，不指定激活函数
])

# 打印模型结构
model.summary()

2. 🧩 构建简单的神经网络：层次结构与激活函数

神经网络的核心在于其层次结构。通常情况下，神经网络由多个全连接层（Fully Connected Layer）组成，每一层的输出都作为下一层的输入。在这个过程中，激活函数起到至关重要的作用，它赋予网络非线性表达能力，使其可以处理复杂的模式识别问题。

在这里插入图片描述

PyTorch实现：

class MultiLayerNetwork(nn.Module):
    def __init__(self):
        super(MultiLayerNetwork, self).__init__()
        self.layer1 = nn.Linear(10, 64)  # 输入10维，输出64维
        self.layer2 = nn.Linear(64, 32)  # 隐藏层64维，输出32维
        self.output_layer = nn.Linear(32, 1)  # 输出层1维

    def forward(self, x):
        x = torch.relu(self.layer1(x))    # ReLU激活函数
        x = torch.tanh(self.layer2(x))    # Tanh激活函数
        x = torch.sigmoid(self.output_layer(x))  # 输出层Sigmoid
        return x

# 创建模型实例
model = MultiLayerNetwork()
print(model)

TensorFlow实现：

model = models.Sequential([
    layers.Dense(64, activation='relu', input_shape=(10,)),  # 第一层使用ReLU激活
    layers.Dense(32, activation='tanh'),  # 第二层使用Tanh激活
    layers.Dense(1, activation='sigmoid')  # 输出层使用Sigmoid激活
])

# 打印模型结构
model.summary()

3. 🚀 前向传播：神经网络的数据流动

前向传播（Forward Propagation）是神经网络的核心过程之一。它是指从输入层开始，信息逐层传递并最终在输出层生成预测结果的过程。在每一层，输入数据通过权重矩阵变换，经过激活函数处理后，再传递到下一层。

在这里插入图片描述

PyTorch实现：

# 定义前向传播函数
def forward_pass(model, inputs):
    output = model(inputs)  # 前向传播
    return output

# 示例：使用随机输入数据进行前向传播
inputs = torch.rand(1, 10)  # 随机生成10维输入数据
output = forward_pass(model, inputs)
print("预测输出：", output)

TensorFlow实现：

# 示例：使用随机输入数据进行前向传播
inputs = tf.random.normal([1, 10])  # 随机生成10维输入数据
output = model(inputs)  # 前向传播
print("预测输出：", output.numpy())

4. 🎯 损失函数与代价函数：神经网络的误差度量

在神经网络的训练过程中，损失函数（Loss Function）用于度量预测结果与真实值之间的误差，进而指导模型的学习过程。损失函数的选择直接影响模型的性能，因此是构建神经网络时的一个重要部分。

在这里插入图片描述

PyTorch实现：

# 定义损失函数
criterion_mse = nn.MSELoss()  # 均方误差损失函数
criterion_ce = nn.BCELoss()   # 二分类交叉熵损失函数

# 示例：计算损失
true_values = torch.tensor([1.0, 0.0])  # 真实标签
predicted_values = torch.tensor([0.8, 0.2])  # 模型预测

# 计算损失
loss_mse = criterion_mse(predicted_values, true_values)
loss_ce = criterion_ce(predicted_values, true_values)

print("均方误差损失：", loss_mse.item())
print("交叉熵损失：", loss_ce.item())

TensorFlow实现：

# 定义损失函数
mse_loss_fn = tf.keras.losses.MeanSquaredError()  # 均方误差
bce_loss_fn = tf.keras.losses.BinaryCrossentropy()  # 二分类交叉熵

# 示例：计算损失
true_values = tf.constant([1.0, 0.0])  # 真实标签
predicted_values = tf.constant([0.8, 0.2])  # 模型预测

# 计算损失
loss_mse = mse_loss_fn(true_values, predicted_values)
loss_bce = bce_loss_fn(true_values, predicted_values)

print("均方误差损失：", loss_mse.numpy())
print("交叉熵损失：", loss_bce.numpy())

5. 🔄 反向传播算法：模型的参数优化机制

反向传播（Backpropagation）是神经网络中的关键算法，用于通过计算梯度来更新网络中的权重，以最小化损失函数。反向传播的目标是找到损失函数相对于每个参数的偏导数，并使用这些梯度来调整模型参数。

反向传播的步骤可以概括为：

计算损失函数的梯度：对于每个参数，计算损失函数对其的偏导数（梯度）。
权重更新：使用优化器，根据梯度信息更新每个参数的值。

梯度的计算过程依赖于链式法则，从损失函数到每个参数逐层计算梯度，这个过程就是反向传播。

PyTorch实现：

# 使用SGD优化器
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

# 示例：前向传播计算损失
inputs = torch.rand(1, 10)
true_values = torch.tensor([1.0])  # 真实标签
predicted_values = model(inputs)
loss = criterion_mse(predicted_values, true_values)

# 反向传播并更新权重
optimizer.zero_grad()  # 清空之前的梯度
loss.backward()        # 反向传播计算梯度
optimizer.step()       # 更新权重

print("更新后的权重：", model.layer1.weight)

TensorFlow实现：

# 使用SGD优化器
optimizer = tf.keras.optimizers.SGD(learning_rate=0.01)

# 示例：前向传播并计算损失
inputs = tf.random.normal([1, 10])
true_values = tf.constant([1.0])  # 真实标签
with tf.GradientTape() as tape:
    predicted_values = model(inputs)
    loss = mse_loss_fn(true_values, predicted_values)

# 计算梯度并更新权重
grads = tape.gradient(loss, model.trainable_weights)
optimizer.apply_gradients(zip(grads, model.trainable_weights))

print("更新后的权重：", model.layers[0].weights[0])

6. 🛠️ 常见优化器解析：从梯度下降到自适应优化

优化器是控制模型参数更新的关键因素，不同的优化器有不同的性能表现。这里展示如何使用几种常见的优化器，包括随机梯度下降（SGD）和Adam优化器。

PyTorch实现：

# SGD优化器
optimizer_sgd = torch.optim.SGD(model.parameters(), lr=0.01)

# Adam优化器
optimizer_adam = torch.optim.Adam(model.parameters(), lr

=0.001)

# 示例：更新权重
optimizer_sgd.step()  # 使用SGD更新
optimizer_adam.step()  # 使用Adam更新

TensorFlow实现：

# SGD优化器
optimizer_sgd = tf.keras.optimizers.SGD(learning_rate=0.01)

# Adam优化器
optimizer_adam = tf.keras.optimizers.Adam(learning_rate=0.001)

# 示例：更新权重
optimizer_sgd.apply_gradients(zip(grads, model.trainable_weights))  # 使用SGD更新
optimizer_adam.apply_gradients(zip(grads, model.trainable_weights))  # 使用Adam更新

7. 🧠 实战：训练与调优深度神经网络模型

在模型训练过程中，使用数据进行多次迭代，通过前向传播、计算损失和反向传播来优化网络。以下展示如何在PyTorch和TensorFlow中执行完整的训练过程。

PyTorch实现：

# 定义训练函数
def train_model(model, data_loader, optimizer, criterion, epochs=10):
    for epoch in range(epochs):
        for inputs, labels in data_loader:
            optimizer.zero_grad()             # 清空梯度
            outputs = model(inputs)           # 前向传播
            loss = criterion(outputs, labels) # 计算损失
            loss.backward()                   # 反向传播
            optimizer.step()                  # 更新权重
        print(f"Epoch {epoch+1}/{epochs}, Loss: {loss.item()}")

# 示例数据加载器
data_loader = [(torch.rand(1, 10), torch.rand(1)) for _ in range(100)]
train_model(model, data_loader, optimizer_adam, criterion_mse)

TensorFlow实现：

# 定义训练函数
def train_model(model, dataset, optimizer, loss_fn, epochs=10):
    for epoch in range(epochs):
        for inputs, labels in dataset:
            with tf.GradientTape() as tape:
                predictions = model(inputs)
                loss = loss_fn(labels, predictions)
            grads = tape.gradient(loss, model.trainable_weights)
            optimizer.apply_gradients(zip(grads, model.trainable_weights))
        print(f"Epoch {epoch+1}/{epochs}, Loss: {loss.numpy()}")

# 示例数据集
dataset = tf.data.Dataset.from_tensor_slices((tf.random.normal([100, 10]), tf.random.normal([100, 1]))).batch(10)
train_model(model, dataset, optimizer_adam, mse_loss_fn)

8. 📊 结果评估与模型调试：准确率与过拟合问题分析

在训练模型后，需要对模型的性能进行评估，并监测是否发生了过拟合。可以使用验证集来检测模型的泛化能力。以下展示如何进行评估。

PyTorch实现：

# 模型评估
def evaluate_model(model, data_loader, criterion):
    model.eval()  # 评估模式，不会计算梯度
    total_loss = 0
    with torch.no_grad():
        for inputs, labels in data_loader:
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            total_loss += loss.item()
    print(f"平均损失：{total_loss / len(data_loader)}")

# 示例：评估模型
evaluate_model(model, data_loader, criterion_mse)

TensorFlow实现：

# 模型评估
def evaluate_model(model, dataset, loss_fn):
    total_loss = 0
    for inputs, labels in dataset:
        predictions = model(inputs)
        loss = loss_fn(labels, predictions)
        total_loss += loss.numpy()
    print(f"平均损失：{total_loss / len(dataset)}")

# 示例：评估模型
evaluate_model(model, dataset, mse_loss_fn)

原文地址：https://blog.csdn.net/weixin_52392194/article/details/143033106

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：从算盘到云计算：计算机发展的壮丽历程
下一篇：jetson agx orin 的pytorch、torchvision安装

一次性入门三款分布式定时任务调度框架：Quartz、ElasticJob3.0、xxl-job
三款分布式任务调度框架，一篇文章全部入门
阅读更多2024-10-19
Python OpenCV精讲系列 - 目标检测与识别深入理解（二十）
Haar特征是一种简单的图像特征，用于检测局部图像结构的变化。它由一组简单的黑色和白色矩形组成，用于计算图像中不同区域之间的平均像素强度差异。HOG（Histogram of Oriented Gra
阅读更多2024-10-19
OpenMediaVault安装插件以及重置web控制台密码
需要安装好openmediavault-md插件。
阅读更多2024-10-19
快速了解kubernetes中的存储管理
Secret 对象类型用来保存敏感信息，例如密码、OAuth 令牌和 ssh key。- 敏感信息放在 secret 中比放在 Pod 的定义或者容器镜像中来说更加安全和灵活- Pod 可以用两种方式
阅读更多2024-10-19
代理 IP：促进在线教育资源普及与公平的新助力
当某个地区的网络拥堵时，学生可以通过代理 IP 选择其他网络较为畅通的线路，确保学习的顺畅进行。对于一些教育资源匮乏的地区，代理 IP 可以帮助学生访问其他地区的在线教育平台，获取更多的学习资料、课程
阅读更多2024-10-19
代码训练营 day38|LeetCode 62，LeetCode 63
今天主要学习了dp的一系列操作，今天难度不大，有点dp那味儿了加油，坚持打卡的第38天。
阅读更多2024-10-19
Dynamic 3D Gaussians: Tracking by Persistent Dynamic View Synthesis 阅读
Dynamic 3D Gaussians:Tracking by Persistent Dynamic View Synthesis 论文阅读
阅读更多2024-10-19
JS模块化及import、export
本文探讨了模块化编程的背景与目的，强调了通过降低代码重复、提高可读性和便于维护等优势来改善软件开发过程。文章还介绍了五大模块化原则，包括单一职责原则和依赖倒置原则，以确保代码的灵活性和可扩展性。此外，
阅读更多2024-10-19
css 如何根据子元素给他的父元素设置样式
'active' : 'unactive' }">子元素啊根据一个变量来加样式</div>其中能马上想到的就是：这个class的判断可以加在parent后面，但是如果不改变
阅读更多2024-10-19
前端学习---(2)CSS基础
关于文字样式的属性，都具有继承性。这些属性包括：color、 text-开头的、line-开头的、font-开头的。CSS 是用来指定文档如何展示给用户的一门语言——如网页的样式、布局、等等。css语
阅读更多2024-10-19

神经网络构建与训练深度学习模型全过程（PyTorch & TensorFlow）