PyTorch 与 TensorFlow 模型搭建的区别

Niuguangshuo2024-11-19 17:42

PyTorch 与 TensorFlow 模型搭建的区别

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

1. PyTorch 的动态性

动态计算图

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

示例代码

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

python 复制代码 
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 中，卷积层、全连接层和池化层的定义需要显式指定输入和输出通道数。例如：

python 复制代码 
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 时。例如：

python 复制代码 
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 中，训练过程需要手动管理梯度清零、损失计算和权重更新。例如：

python 复制代码 
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 方法自动处理。例如：

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

torch代码

python 复制代码 
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代码

python 复制代码 
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()
相关推荐
狐凄19 分钟前
AI 在软件开发
人工智能
学步_技术21 分钟前
自动驾驶系列—自动驾驶数据脱敏：保护隐私与数据安全的关键技术
人工智能·机器学习·自动驾驶·数据安全·数据脱敏
学步_技术21 分钟前
自动驾驶系列—深入解析自动驾驶车联网技术及其应用场景
人工智能·机器学习·自动驾驶·车联网
whaosoft-14322 分钟前
51c自动驾驶~合集27
人工智能
数据智研29 分钟前
【数据分享】中国食品工业年鉴(1984-2023) PDF
大数据·人工智能·pdf
chenchihwen30 分钟前
大型语言模型综述 A Survey of Large Language Models
人工智能·语言模型·自然语言处理
Ruannn（努力版）32 分钟前
数据挖掘复习
人工智能·数据挖掘
OT.Ter33 分钟前
基于FastAPI实现本地大模型API封装调用
人工智能·算法·大模型·fastapi
vivid_blog35 分钟前
大语言模型（LLM）入门级选手初学教程 四
人工智能·语言模型·自然语言处理
Ashleyyyi36 分钟前
论文阅读：Mixture-of-Agents Enhances Large Language Model Capabilities
人工智能·语言模型·自然语言处理
热门推荐
01PyTorch机器学习实现液态神经网络02聊聊 Python 中的同步原语，为什么有了 GIL 还需要同步原语03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04Coze扣子平台完整体验和实践（附国内和国际版对比）05玄机平台应急响应—webshell查杀06组基轨迹建模 GBTM的介绍与实现（Stata 或 R）07小白零基础学数学建模系列-Day8-多目标规划问题与案例实践08RAG 实践- Ollama+RagFlow 部署本地知识库09Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO10手部关键点检测2：YOLOv5实现手部检测(含训练代码和数据集)