当前位置： 首页 > article >正文

PyTorch 与 TensorFlow 模型搭建的区别

article 2024/11/19 19:59:13

PyTorch 与 TensorFlow 模型搭建的区别

在深度学习领域，PyTorch 和 TensorFlow 是两个最流行的框架。本文将通过手写数字识别（MNIST 数据集）作为例子，探讨这两个框架在模型搭建中的主要区别，包括 PyTorch 的动态性、卷积层、全连接层和池化层的定义差异，以及训练过程的不同。

1. PyTorch 的动态性

动态计算图

PyTorch 使用动态计算图（Define-by-Run），这意味着计算图在每次前向传播时都是动态生成的。您可以在模型运行时根据输入数据的形状和内容灵活地修改网络结构。这种特性使得调试和实验变得更加简单。

示例代码

在 PyTorch 的手写数字识别代码中，模型的定义如下：

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)  # 第一层卷积
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)  # 池化层
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)  # 第二层卷积
        self.fc1 = nn.Linear(64 * 7 * 7, 128)  # 全连接层
        self.fc2 = nn.Linear(128, 10)  # 输出层

    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))  # 通过第一层卷积和池化
        x = self.pool(torch.relu(self.conv2(x)))  # 通过第二层卷积和池化
        x = x.view(-1, 64 * 7 * 7)  # 展平特征图
        x = torch.relu(self.fc1(x))  # 通过全连接层
        x = self.fc2(x)  # 输出层
        return x

在 forward 方法中，=可以根据输入数据的形状和内容灵活调整模型结构。调试时，可以使用标准的 Python 调试工具（如 print 语句）来逐步检查中间结果。

2. 卷积层、全连接层和池化层的定义差异

PyTorch 中的定义

在 PyTorch 中，卷积层、全连接层和池化层的定义需要显式指定输入和输出通道数。例如：

self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)  # 第一层卷积
self.pool = nn.MaxPool2d(kernel_size=2, stride=2)  # 池化层
self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)  # 第二层卷积
self.fc1 = nn.Linear(64 * 7 * 7, 128)  # 全连接层
self.fc2 = nn.Linear(128, 10)  # 输出层
  • 卷积层：需要明确输入和输出通道数。
  • 池化层：定义池化操作的类型和大小。
  • 全连接层：输入特征数和输出特征数需要明确。

TensorFlow 中的定义

在 TensorFlow 中，卷积层、全连接层和池化层的定义通常不需要显式指定输入通道数，尤其是在使用 Keras 的 layers.Conv2D 时。例如：

model = models.Sequential([
    layers.Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1)),  # 第一层卷积
    layers.MaxPooling2D(pool_size=(2, 2)),  # 池化层
    layers.Conv2D(64, kernel_size=(3, 3), activation='relu'),  # 第二层卷积
    layers.MaxPooling2D(pool_size=(2, 2)),  # 池化层
    layers.Flatten(),  # 展平
    layers.Dense(128, activation='relu'),  # 全连接层
    layers.Dense(10, activation='softmax')  # 输出层
])
  • 卷积层：在第一层中需要指定 input_shape，后续层会自动推断输入通道数。
  • 池化层：定义池化操作的类型和大小。
  • 全连接层：通过 layers.Dense 添加，输入特征数会自动推断。

3. 训练的区别

PyTorch 的训练过程

在 PyTorch 中，训练过程需要手动管理梯度清零、损失计算和权重更新。例如：

for epoch in range(num_epochs):
    for images, labels in train_loader:
        optimizer.zero_grad()  # 清除梯度
        outputs = model(images)  # 前向传播
        loss = criterion(outputs, labels)  # 计算损失
        loss.backward()  # 反向传播
        optimizer.step()  # 更新权重
  • 手动控制：每一步都需要手动管理，提供了更大的灵活性，但也需要更多的代码。

TensorFlow 的训练过程

在 TensorFlow 中，训练过程通过 model.fit 方法自动处理。例如：

model.fit(x_train, y_train, batch_size=batch_size, epochs=num_epochs, verbose=1)
  • 自动管理：TensorFlow 会自动处理梯度计算、损失计算和权重更新，简化了训练过程。

torch代码

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt

# 超参数
batch_size = 64
learning_rate = 0.001
num_epochs = 5

# 数据预处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

# 下载 MNIST 数据集
train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
test_dataset = datasets.MNIST(root='./data', train=False, transform=transform)

train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)


# 定义卷积神经网络模型
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        # 第一层卷积，输入通道为1（灰度图），输出通道为32，卷积核大小为3x3
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)
        # 池化层，使用2x2的最大池化
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        # 第二层卷积，输入通道为32，输出通道为64
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
        # 全连接层，输入特征数为64*7*7（经过两次池化后的特征图大小），输出特征数为128
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        # 输出层，输出特征数为10（数字0-9）
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        # 前向传播过程
        x = self.pool(torch.relu(self.conv1(x)))  # 通过第一层卷积和池化
        x = self.pool(torch.relu(self.conv2(x)))  # 通过第二层卷积和池化
        x = x.view(-1, 64 * 7 * 7)  # 展平特征图
        x = torch.relu(self.fc1(x))  # 通过全连接层
        x = self.fc2(x)  # 输出层
        return x


# 实例化模型、损失函数和优化器
model = CNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# 训练模型
for epoch in range(num_epochs):
    for images, labels in train_loader:
        optimizer.zero_grad()  # 清除梯度
        outputs = model(images)  # 前向传播
        loss = criterion(outputs, labels)  # 计算损失
        loss.backward()  # 反向传播
        optimizer.step()  # 更新权重

    print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')

# 测试模型并展示结果
model.eval()  # 切换到评估模式
with torch.no_grad():
    # 选择几张测试图片
    data_iter = iter(test_loader)
    images, labels = next(data_iter)
    outputs = model(images)

    # 获取预测结果
    _, predicted = torch.max(outputs.data, 1)

    # 绘制结果
    fig, axes = plt.subplots(1, 5, figsize=(12, 4))
    for i in range(5):
        axes[i].imshow(images[i][0], cmap='gray')  # 显示灰度图像
        axes[i].set_title(f'Predicted: {predicted[i].item()}, Actual: {labels[i].item()}')
        axes[i].axis('off')
    plt.show()

tensorflow代码

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import mnist
import matplotlib.pyplot as plt

# 超参数
batch_size = 64
learning_rate = 0.001
num_epochs = 5

# 下载 MNIST 数据集
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.astype('float32') / 255.0  # 归一化
x_test = x_test.astype('float32') / 255.0

# 数据预处理
x_train = x_train.reshape(-1, 28, 28, 1)  # 添加通道维度
x_test = x_test.reshape(-1, 28, 28, 1)  # 添加通道维度

# 定义卷积神经网络模型
model = models.Sequential([
    layers.Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1)),  # 第一层卷积
    layers.MaxPooling2D(pool_size=(2, 2)),  # 池化层
    layers.Conv2D(64, kernel_size=(3, 3), activation='relu'),  # 第二层卷积
    layers.MaxPooling2D(pool_size=(2, 2)),  # 池化层
    layers.Flatten(),  # 展平
    layers.Dense(128, activation='relu'),  # 全连接层
    layers.Dense(10, activation='softmax')  # 输出层
])

# 编译模型
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=learning_rate),
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# 训练模型
model.fit(x_train, y_train, batch_size=batch_size, epochs=num_epochs, verbose=1)

# 测试模型并展示结果
test_loss, test_accuracy = model.evaluate(x_test, y_test, verbose=2)
print(f'Accuracy of the model on the test images: {test_accuracy * 100:.2f}%')

# 选择几张测试图片
predictions = model.predict(x_test)
predicted_classes = tf.argmax(predictions, axis=1)

# 绘制结果
fig, axes = plt.subplots(1, 5, figsize=(12, 4))
for i in range(5):
    axes[i].imshow(x_test[i].reshape(28, 28), cmap='gray')  # 显示灰度图像
    axes[i].set_title(f'Predicted: {predicted_classes[i].numpy()}, Actual: {y_test[i]}')
    axes[i].axis('off')
plt.show()

在这里插入图片描述


http://www.kler.cn/a/400532.html

相关文章：

  • 【git】git取消提交的内容，恢复到暂存区
  • 【2】猫眼娱乐后端开发面试题整理
  • 51单片机--- 矩阵按键仿真
  • 《Django 5 By Example》阅读笔记：p645-p650
  • vscode文件重定向输入输出（竞赛向）
  • 如何在MindMaster思维导图中制作PPT课件？
  • 前端处理input框只能输入带小数点的数字
  • gin源码阅读（1）URL中的参数是如何解析的？
  • FastApi学习第二天：Pydantic对数据的校验和Form表单数据
  • 力扣题解661 图片平滑器
  • 三周精通FastAPI：42 手动运行服务器 - Uvicorn Gunicorn with Uvicorn
  • 群控系统服务端开发模式-应用开发-前端管理员功能开发
  • BLE 蓝牙客户端和服务器连接
  • 纯前端实现语音文字互转
  • 大模型实操练习二、文心大模型API使用方法(入门阶段)
  • 离散数学笔记
  • 【ASR技术】WhisperX安装使用
  • 【论文阅读】InstructPix2Pix: Learning to Follow Image Editing Instructions
  • 键盘上打出反引号符号（´），即单个上标的撇号（这个符号与反引号 ` 不同，反引号通常位于键盘的左上角）
  • DBeaver MACOS 安装 并连接到docker安装的mysql
  • Android 开发与救砖工具介绍
  • Fisher矩阵和Hessian矩阵的关系：证明Fisher为负对数似然函数的Hessian的期望
  • LeetCode 2816.翻倍以链表形式表示的数字
  • 消息队列原理面试题及参考答案
  • 手搓神经网络（MLP）解决MNIST手写数字识别问题 | 数学推导+代码实现 | 仅用numpy，tensor和torch基本计算 | 含正反向传播数学推导
  • 开源控件：Qt/C++自定义颜色组合框控件ColorComboBox